Course Overview
This boot camp introduces participants to docker and its ecosystem, help them get started using Docker to build, package and run their applications inside containers. This course also covers container orchestration with Kubernetes.
This course covers docker right from how to run a single container, to how to package your application into a docker image and finally deploying it at a production scale on a multitude of hosts. This course is useful for you if,
- You are a developer and want to understand how Docker works as well as learn to package your application into a docker image. You may also be interested in creating release strategies and deploy it in pre-production or production environments.
- You are operations personnel who would like to understand how to get started with containers, troubleshoot issues, support docker environments. You may also want to understand how to design and deploy a highly available, fault tolerant production scale infrastructure with Kubernetes, understand the network primitives, etc.
- You are a QA and would like to understand how to use Docker to set up test environments, speed up testing and continuous integration process and also learn how container orchestration works with Kubernetes.
Requirements
- Linux/Unix Systems Fundaments
- Understanding of Command Line Interface
- Basic knowledge of editors on Linux (any one of vi/nano/emacs)
- Understanding of YAML syntax and familiarity with reading/writing basic YAML specifications
Curriculum
-
Day 1
- Basics of Docker
- Dockerfile
- Networking
- Creating and Running Containers : Container Images
- Creating and Running Containers: Building Application Images with Docker
- Creating and Running Containers: Storing Images in a Remote Registry
- Creating and Running Containers: The Docker Container Runtime
- Deploying a Kubernetes Cluster: Installing Kubernetes on a Public Cloud Provider
- Deploying a Kubernetes Cluster: Installing Kubernetes Locally Using minikube
- Deploying a Kubernetes Cluster: Running Kubernetes on Raspberry Pi
- Deploying a Kubernetes Cluster: The Kubernetes Client
- Deploying a Kubernetes Cluster: Cluster Components
- Common kubectl Commands : Namespaces
- Common kubectl Commands : Contexts
- Common kubectl Commands :Viewing Kubernetes API Objects
- Common kubectl Commands :Creating, Updating, and Destroying Kubernetes Objects
- Common kubectl Commands :Labelling and Annotating Objects
- Common kubectl Commands :Debugging Commands
- Pods : Pods in Kubernetes
- Pods : The Pod Manifest
- Pods : Running Pods
- Pods : Accessing Pod
- Pods : Health Checks
- Pods : Resource Management
- Pods : Persisting Data with Volumes
- Labels and Annotations : Labels
- Pods : The Distributed System ToolKit (Sidecar containers, Ambassador containers, Adapter containers)
- Labels and Annotations : Annotations
- Resource Quotas : Enabling Resource Quota
- Resource Quotas : Compute Resource Quota
- Resource Quotas : Storage Resource Quota
- Resource Quotas : Object Count Quota
- Resource Quotas : Requests vs Limits
- Resource Quotas : Quota Scopes
- Resource Quotas : Viewing and Setting Quotas
- Resource Quotas : Quota and Cluster Capacity
- Resource Quotas : Limit Priority Class consumption by default
-
Day 2
- Service Discovery : What Is Service Discovery?
- Service Discovery : Using CoreDNS for Service Discovery
- Service Discovery : About CoreDNS
- Service Discovery : Upgrading an existing cluster with kubeadm
- Service Discovery : Installing kube-dns instead of CoreDNS with kubeadm
- Service Discovery : The Service Object
- Service Discovery : Looking Beyond the Cluster
- Service Discovery : Cloud Integration
- Service Discovery : Advanced Details
- ReplicaSets : Reconciliation Loops
- ReplicaSets : Relating Pods and ReplicaSets
- ReplicaSets : Designing with ReplicaSets
- ReplicaSets : ReplicaSet Spec
- ReplicaSets : Creating a ReplicaSet
- ReplicaSets : Inspecting a ReplicaSet
- ReplicaSets : Scaling ReplicaSets
- ReplicaSets : Deleting ReplicaSets
- DaemonSets : DaemonSet Scheduler
- DaemonSets : Creating DaemonSets
- DaemonSets : Limiting DaemonSets to Specific Nodes
- DaemonSets : Updating a DaemonSet
- DaemonSets : Deleting a DaemonSet
- Jobs : The Job Object
- Jobs : Job Patterns
- ConfigMaps and Secrets : ConfigMaps
- ConfigMaps and Secrets : Secrets
- ConfigMaps and Secrets : Naming Constraints
- ConfigMaps and Secrets : Managing ConfigMaps and Secrets
- Deployments : First Deployment
- Deployments : Creating Deployments
- Deployments : Managing Deployments
- Deployments : Updating Deployments
- Deployments : Deleting a Deployment
- Deployments : Deployment Strategies
- Integrating Storage Solutions and Kubernetes : Importing External Services
- Integrating Storage Solutions and Kubernetes : Running Reliable Singletons
- Integrating Storage Solutions and Kubernetes : Kubernetes-Native Storage with StatefulSets
- The Ecosystem : Installing Helm, the Kubernetes Package Manager
- The Ecosystem : Using Helm to Install Applications
- The Ecosystem : Creating Your Own Chart to Package Your Application with Helm
- The Ecosystem : Converting Your Docker Compose Files to Kubernetes Manifests
- The Ecosystem : Creating a Kubernetes Cluster with kubicorn
- The Ecosystem : Storing Encrypted Secrets in Version Control
- The Ecosystem : Deploying Functions with kubeless
-
Day 3
- Deploying Real-World Applications : Parse
- Deploying Real-World Applications : Ghost
- Deploying Real-World Applications : Redis
- Service Mesh : Why service mesh?
- Service Mesh : Conduit and Istio
- Service Mesh : Managing microservices with Istio
- Authorization Overview : Determine Whether a Request is Allowed or Denied
- Authorization Overview : Review Your Request Attributes
- Authorization Overview : Determine the Request Verb
- Authorization Overview : Authorization Modules
- Authorization Overview : Using Flags for Your Authorization Module
- Authorization Overview : Privilege escalation via pod creation
- Networking : Calico
- Networking : Flannel
- Scaling : Scaling a Deployment
- Scaling : Automatically Resizing a Cluster in GKE
- Scaling : Automatically Resizing a Cluster in AWS
- Scaling : Using Horizontal Pod Autoscaling on GKE
- Security : Providing a Unique Identity for an Application
- Security : Listing and Viewing Access Control Information
- Security : Controlling Access to Resources
- Security : Securing Pods
- Ingress Controller : What is Ingress?
- Ingress Controller : Prerequisites
- Ingress Controller : The Ingress Resource
- Ingress Controller : Ingress controllers
- Ingress Controller : Before you begin
- Ingress Controller : Types of Ingress
- Ingress Controller : Updating an Ingress
- Ingress Controller : Failing across availability zones
- Ingress Controller : Future Work
- Ingress Controller : Alternatives
- Monitoring and Logging : Accessing the Logs of a Container
- Monitoring and Logging : Recover from a Broken State with a Liveness Probe
- Monitoring and Logging : Controlling Traffic Flow to a Pod Using a Readiness Probe
- Monitoring and Logging : Adding Liveness and Readiness Probes to Your Deployments
- Monitoring and Logging : Enabling Heapster on Minikube to Monitor Resources
- Monitoring and Logging : Using Prometheus on Minikube
- Monitoring and Logging : Using Elasticsearch–Fluentd–Kibana (EFK) on Minikube