Docker and Kubernetes Fundamentals

Docker and Kubernetes Fundamentals Courseware (WA3003)

This intensive Docker and Kubernetes training course offers a combination of theoretical concepts as well as real-world hands-on labs, giving students the opportunity to apply their knowledge. The course covers essential Kubernetes and Docker skills and provides a basic introduction to Continuous Integration.

Who should attend

Developers, system architects, technical team leads, systems administrators, and DevOps professionals who want to understand and use Kubernetes in cloud environments.

Publisher: Web Age Solutions

Benefits

  • Learn the fundamental uses of container technology and the architectural principles of how to apply containers to technical challenges.
  • Create containers with both packaged solutions and custom software.
  • Use the Docker and Kubernetes CLI environments to deploy solutions in local (Docker) and cluster (Kubernetes) environments.
  • Learn how stateful services – such as databases, streaming solutions , and other specialty applications  – can be deployed in highly-available configurations with redundancy and service-discovery/load-balancing.
  • Show how other components – can be used to integrate services within the Kubernetes platform.
  • Explore how Docker and technologies such as Jenkins can be used to continuously test and build containers based on changes to source code.

Outline

  1. Docker and Linux Container Technology: Introduction and Use-Cases
    1. Modern Infrastructure Terminology
    2. Virtualization
    3. Hypervisors
    4. Hypervisor Types
    5. Type 1 Hypervisors
    6. Type 2 Hypervisors
    7. Type 1 vs Type 2 Processing
    8. Paravirtualization
    9. Virtualization Qualities (1/2)
    10. Virtualization Qualities (2/2)
    11. Disadvantages of Virtualization
    12. Containerization
    13. Virtualization vs Containerization
    14. Where to Use Virtualization and Containerization
    15. Containerization: High-Level
    16. Popular Containerization Systems
    17. What are Linux Containers
    18. Docker
    19. OpenVZ
    20. Solaris Zones (Containers)
    21. Container Orchestration Tools
    22. Docker Swarm
    23. Kubernetes
    24. Mesos and Marathon
    25. Docker Use-Cases
    26. Microservices
    27. Microservices and Containers / Clusters
  2. Docker in Action
    1. Docker Basics
    2. Where Can I Run Docker?
    3. Installing Docker Container Engine
    4. Docker Toolbox
    5. What is Docker?
    6. Docker Architecture
    7. Docker Architecture Diagram
    8. Docker Images
    9. Docker Containers
    10. Docker Integration
    11. Docker Services
    12. Docker Application Container Public Repository
    13. Docker Run Command
    14. Starting, Inspecting, and Stopping Docker Containers
    15. Docker Volume
    16. Dockerfile
    17. Docker Compose
    18. Using Docker Compose
    19. Dissecting docker-compose.yml
      1. Specifying services
    20. Dependencies between containers
    21. Injecting Environment Variables
  3. Managing Docker State
    1. State and Data in Docker
    2. Volumes
    3. More About Volumes
    4. Uses for Volumes
    5. Working With Volumes
    6. Create Volume
    7. Use Volumes with Containers
    8. Bind Mounts
    9. Using Bind Mounts
    10. tmpfs Mounts
    11. Storing Data in the Container
    12. Storage Drivers
    13. Remote Data Storage
    14. Networking
    15. The Default Bridge Network
    16. User-Defined Bridge Networks
    17. Docker Network Commands
    18. Creating a User-Defined Bridge Network
  4. Open Container Initiative and Container Runtime Interface
    1. Open Container Initiative (OCI)
    2. Docker
    3. Docker Engine Architecture
    4. runC
    5. containerd
    6. containerd Benefits
    7. CRI-O
    8. CRI-O Components
    9. Kubernetes and CRI-O
    10. Using Container Runtimes with Minikube
    11. Docker Runtime and Kubernetes
    12. Putting Things Together
  5. Kubernetes Architecture
    1. Kubernetes Basics
    2. What is Kubernetes?
    3. Container Orchestration
    4. Architecture Diagram
    5. Components
    6. Kubernetes Cluster
    7. Master Node
    8. Kube-Control-Manager
    9. Nodes
    10. Pod
    11. Using Pods to Group Containers
    12. Label
    13. Label Syntax
    14. Label Selector
    15. Annotation
    16. Persistent Storage
    17. Resource Quota
    18. Interacting with Kubernetes
  6. Working with Kubernetes
    1. Installation
    2. Startup
    3. Kubernetes Tools
    4. kubectl Command Line Interface
    5. API Proxy
    6. Dashboard
    7. Kubernetes Component Hierarchy
    8. Deployments
    9. Deployment Commands
    10. Updating Deployments
    11. Network Considerations
    12. Services
    13. Namespaces
    14. Labels
    15. Annotations
    16. Other Useful Commands
  7. Kubernetes Workload
    1. Kubernetes Workload
    2. Managing Workloads
    3. Imperative commands
    4. Imperative Object Configuration
    5. Declarative Object Configuration
    6. Configuration File Schema
    7. Understanding API Version
    8. Understanding API Version
    9. Obtaining API Versions
    10. Stateless Applications
    11. Sample Deployment Manifest File
    12. Working with Deployments
    13. Stateful Applications
    14. Sample Stateful Manifest File
    15. Working with StatefulSet
    16. Jobs
    17. Sample Job Manifest File
    18. Working with Batch Job
    19. DaemonSets
    20. Sample Daemon Manifest File
    21. Rolling Updates
  8. Scheduling and Node Management
    1. Kubernetes Scheduler
    2. Skip Kubernetes Scheduler
    3. Scheduling Process
    4. Scheduling Process - Predicates
    5. Scheduling Process - Priorities
    6. Scheduling Algorithm
    7. Kubernetes Scheduling Algorithm
    8. Scheduling Conflicts
    9. Controlling Scheduling
    10. Label Selectors
    11. Node Affinity and Anti-affinity
    12. Node Affinity Example
    13. Node Antiaffinity Example
    14. Taints and Tolerations
    15. Taints and Tolerations - Example
  9. Managing Networking
    1. Kubernetes Networking Components
    2. The Kubernetes Network Model
    3. Networking Scenarios
    4. Container-Container Communication
    5. Pod-Pod Communication
    6. 1.3 Pod-Service Communication
    7. External-Service Communication
    8. Accessing Applications
    9. Useful Commands
    10. Container Network Interface (CNI)
    11. What is CNI's Role?
    12. CNI Configuration Format
    13. Sample CNI Configuration
    14. Running the CNI Plugins
  10. Managing Persistent Storage
    1. Storage Methods
    2. Container OS file system storage
    3. Docker Volumes
    4. Kubernetes Volumes
    5. K8S Volume Types
    6. Cloud Resource Types
    7. configMaps
    8. Creating configMaps from Literals
    9. Creating configMaps from files
    10. Using configMaps
    11. emptyDir
    12. Using an emptyDir Volume
    13. Other Volume Types
    14. Persistent Volumes
    15. Creating a Volume
    16. Persistent Volume Claim
    17. Persistent Volume
    18. Pod that uses Persistent Volume
    19. Secrets
    20. Creating Secrets from Files
    21. Creating Secrets from Literals
    22. Using Secrets
    23. Security Context
    24. Security Context Usage
  11. Working with Helm
    1. What is Helm?
    2. Installing Helm
    3. Helm and KUBECONFIG
    4. Helm Features
    5. Helm Terminology
    6. Searching for Charts with helm CLI
    7. Adding Repositories
    8. Helm Hub - Search
    9. Helm Hub - Chart Page
    10. Installing a Chart
    11. Upgrading a Release
    12. Rolling Back a Release
    13. Creating Custom Charts
    14. Common Chart Files
    15. Helm Templates
    16. Installing A Custom Chart
    17. Packaging Custom Charts
  12. Logging, Monitoring, and Troubleshooting
    1. Differences Between Logging and Monitoring
    2. Logging in Kubernetes
    3. Basic Logging
    4. Logging Agents
    5. Fluentd and Elastic Stack
    6. Monitoring with Prometheus
    7. Kubernetes and Prometheus - Metrics
    8. Alerting
    9. Debugging Pods
    10. Debugging Nodes
    11. Debugging Replication Controllers and Services
    12. Upgrading Kubernetes
    13. Upgrade Process
    14. Determine Which Version to Upgrade To
    15. Upgrade kubeadm
    16. Upgrade Control Plane Node
    17. Upgrade kubelet and kubectl
    18. Upgrade Worker Nodes
    19. Recovering From a Failure State
  13. Continuous Integration Fundamentals
    1. Jenkins Continuous Integration
    2. Jenkins Features
    3. Running Jenkins
    4. Downloading and Installing Jenkins
    5. Running Jenkins as a Stand-Alone Application
    6. Running Jenkins on an Application Server
    7. Installing Jenkins as a Windows Service
    8. Different types of Jenkins job
    9. Configuring Source Code Management(SCM)
    10. Working with Subversion
    11. Working with Git
    12. Build Triggers
    13. Schedule Build Jobs
    14. Polling the SCM
    15. Maven Build Steps
    16. Configuring Jenkins to Access Kubernetes
    17. Jenkins Pipeline
    18. Jenkins Pipeline Output
    19. Installing Jenkins Plugins
  14. Lab Exercises
    1. Creating a Docker Account and Obtain an Access Token
    2. Managing Containers
    3. Building Images
    4. Dockerfiles
    5. Getting Started with Docker Compose
    6. Docker Volumes
    7. Custom Network Management
    8. Configuring Minikube/Kubernetes to Use a Custom Docker Account
    9. Accessing the Kubernetes API
    10. Working with Kubernetes Workloads
    11. Scheduling and Node Management
    12. Accessing Applications
    13. Using Persistent Storage
    14. Getting Started with Helm
    15. Build CI Pipeline with Jenkins

Required Prerequisites

  • Proficiency with the Linux Command Line Interface (CLI)
  • Broad understanding of Linux system administration: Linux file system, networking, and bash scripting.
  • Computer programming concepts and methodologies. Full code examples for the course are provided in the Python and Java programming languages.
License

Length: 3 days | $225.00 per copy

LicenseRequest More InformationRequest Trainer Evaluation Copy