Container Platforms Administration with Docker, Kubernetes and OpenShift Training Course

Day 1 – Containers and Image Management

Introduction to Container Platforms

• Comparison of traditional application deployment with container-based approaches
• Differences between containers and virtual machines
• Understanding container runtimes and engines
• The respective roles of Docker, Kubernetes, and OpenShift
• Overview of common container platform architectures
• Workflows for development, testing, and production

Working with Containers

• Running and managing containers
• The container lifecycle
• Starting, stopping, and removing containers
• Executing commands within containers
• Utilizing environment variables
• Port mapping techniques
• Accessing and analyzing container logs
• Monitoring resource usage and inspecting processes

Building Container Images

• Understanding image structure and layers
• Authoring Dockerfiles and Containerfiles
• Selecting appropriate base images
• Incorporating application dependencies
• Configuring entry points and commands
• Leveraging image caching for efficiency
• Strategies for reducing image size
• Constructing reproducible images

Container Registries

• Distinguishing between public and private registries
• Tagging and versioning images
• Pushing and pulling images to and from registries
• Managing image authentication
• Implementing image retention policies and cleanup procedures
• Considering basic image security implications

Container Networking and Storage

• Fundamental container networking concepts
• Bridge networking configurations
• Exposing ports to the external environment
• Facilitating container-to-container communication
• Utilizing bind mounts and volumes
• Managing persistent container data
• Key considerations for backup strategies

Hands-on Exercises

• Running and inspecting containers
• Building an application image
• Configuring ports and environment variables
• Publishing an image to a registry
• Storing persistent data external to the container

Day 2 – Kubernetes Architecture and Workloads

Kubernetes Fundamentals

• The purpose and necessity of container orchestration
• Overview of Kubernetes architecture
• Components of the control plane
• Structure and function of worker nodes
• The role of the API server
• Functionality of the scheduler
• Operating principles of controllers
• Distinguishing between cluster state and desired state
• Interacting with the cluster using kubectl

Kubernetes Resources

• Understanding Pods
• Managing ReplicaSets
• Implementing Deployments
• Organizing with Namespaces
• Utilizing labels and annotations
• Applying selectors for object grouping
• Writing declarative resource definitions
• Structuring YAML manifests

Deploying Applications

• Creating and managing Deployments
• Scaling workloads up or down
• Updating container images
• Executing rolling updates
• Performing rollbacks to previous versions
• Reviewing deployment history
• Restarting workloads as needed
• Managing application replicas for high availability

Application Configuration

• Using ConfigMaps for configuration data
• Storing sensitive data with Secrets
• Passing environment variables to applications
• Managing configuration files within the cluster
• Decoupling application code from configuration details
• Handling environment-specific settings efficiently

Resource Management

• Defining CPU and memory requests
• Setting CPU and memory limits
• Implementing resource quotas at the namespace level
• Configuring limit ranges for default constraints
• Understanding scheduling implications of resource limits
• Diagnosing failures related to resource exhaustion

Hands-on Exercises

• Deploying a containerized application
• Creating and updating Kubernetes manifests
• Scaling an application dynamically
• Performing a rolling update followed by a rollback
• Configuring the application using ConfigMaps and Secrets
• Applying resource requests and limits

Day 3 – Kubernetes Networking, Storage, and Security

Kubernetes Networking

• Overview of the cluster networking model
• Facilitating pod-to-pod communication
• Implementing service discovery mechanisms
• Naming and DNS within the cluster
• Configuring ClusterIP services
• Setting up NodePort services
• Utilizing LoadBalancer services
• Understanding Ingress concepts
• Patterns for exposing applications externally

Network Policies

• Controlling traffic flow between workloads
• Defining ingress and egress rules
• Implementing namespace-based traffic control
• Testing network connectivity between pods
• Troubleshooting service communication issues

Persistent Storage

• Differences between ephemeral and persistent storage
• Understanding Volumes in Kubernetes
• Working with PersistentVolumes (PVs)
• Managing PersistentVolumeClaims (PVCs)
• Configuring StorageClasses
• Enabling dynamic provisioning
• Understanding various access modes
• Applying reclaim policies
• Providing storage solutions for stateful applications

Kubernetes Access Control

• Fundamentals of authentication and authorization
• Implementing Role-Based Access Control (RBAC)
• Distinguishing between Roles and ClusterRoles
• Configuring RoleBindings and ClusterRoleBindings
• Managing Service Accounts for pod identity
• Enforcing the principle of least privilege
• Inspecting effective permissions for users and accounts

Workload Security

• Utilizing security contexts for pods and containers
• Running containers with non-root privileges
• Managing Linux capabilities
• Implementing read-only filesystems
• Handling secrets securely within workloads
• Verifying image provenance
• Identifying common configuration risks

Hands-on Exercises

• Exposing an application via Kubernetes services
• Configuring Ingress routes for external access
• Restricting traffic using Network Policies
• Provisioning and attaching persistent storage
• Configuring RBAC permissions for users and groups
• Running a workload with an appropriate security context

Day 4 – Working with OpenShift Environments

Introduction to OpenShift

• Understanding OpenShift as a Kubernetes-based application platform
• Mapping Kubernetes resources to OpenShift equivalents
• Overview of OpenShift cluster architecture
• Differences between Projects and Namespaces in OpenShift
• Managing platform users and service accounts
• Navigating the OpenShift Web Console
• Utilizing the OpenShift CLI (oc command)

Managing Projects and Access

• Creating and managing projects
• Assigning user permissions at the project level
• Understanding project-level roles
• Granting administrative access appropriately
• Configuring resource quotas for projects
• Setting limit ranges for container resources
• Managing service accounts within projects
• Auditing and reviewing project resources

Deploying Applications in OpenShift

• Deploying container images using OpenShift capabilities
• Creating application workloads via BuildConfigs and DeployConfigs
• Managing deployment strategies
• Scaling applications horizontally or vertically
• Updating application versions automatically
• Performing rollbacks to prior revisions
• Managing application configuration securely
• Handling secrets within the OpenShift context

Application Exposure in OpenShift

• Understanding Services within OpenShift
• Configuring Routes for external access
• Implementing TLS/SSL for secure communication
• Differentiating between internal and external application access
• Managing hostnames and certificates for routes
• Troubleshooting common route and service issues

Storage in OpenShift

• Working with Persistent Volume Claims (PVCs)
• Configuring StorageClasses for dynamic provisioning
• Attaching storage volumes to workloads
• Supporting stateful workloads with persistent data
• Managing storage access permissions
• Troubleshooting volume mounting issues

Scheduling and Node Management

• Using labels and selectors for object organization
• Configuring node selectors for workload placement
• Implementing taints and tolerations
• Understanding affinity and anti-affinity scheduling rules
• Strategies for workload placement on nodes
• Cordoning and draining nodes for maintenance
• Considerations for routine node maintenance

Hands-on Exercises

• Accessing an OpenShift environment via CLI and Console
• Creating and configuring a new project
• Deploying and exposing an application using Routes
• Configuring user and service account access controls
• Attaching persistent storage to a workload
• Scaling and updating a running workload

Day 5 – Operations, Monitoring, and Troubleshooting

Platform Monitoring

• Monitoring overall cluster and application health
• Analyzing resource metrics for CPU, memory, and disk
• Assessing node health status
• Checking workload status and readiness
• Evaluating capacity and resource utilization trends
• Identifying performance bottlenecks and constraints

Logging and Events

• Accessing container logs directly
• Retrieving pod-level logs
• Reviewing previous container logs for debugging
• Analyzing Kubernetes events for cluster activity
• Interpreting application and platform messages
• Filtering and interpreting operational data effectively

Health Checks

• Configuring Startup Probes for initialization checks
• Setting up Readiness Probes to manage traffic flow
• Implementing Liveness Probes to detect failures
• Designing effective health endpoint logic
• Diagnosing common probe failure scenarios
• Preventing unnecessary application restarts due to misconfigured probes

Troubleshooting Workloads

• Resolving issues with Pending Pods
• Debugging Image Pull Failures
• Investigating CrashLoopBackOff errors
• Correcting Misconfigured Environment Variables
• Addressing Failed Mounts for volumes
• Handling Insufficient Resources errors
• Resolving Permission Errors during access
• Troubleshooting Service and Route Connectivity Problems
• Fixing DNS resolution issues
• Diagnosing Application Startup Failures

Operational Security

• Auditing and reviewing existing permissions
• Best practices for Service Account usage
• Securely handling credentials and secrets
• Implementing image security scanning and practices
• Ensuring network isolation between workloads
• Auditing platform access logs
• Strictly applying the principle of least privilege

Maintenance and Lifecycle Management

• Conducting routine platform health checks
• Executing node maintenance procedures
• Strategies for application backup and recovery
• Backing up critical configuration files
• Planning for cluster and component updates
• Managing change requests and deployments
• Testing updates in staging environments
• Developing rollback plans for failed updates
• Understanding Disaster Recovery concepts

Final Practical Workshop

Participants will complete an end-to-end operational scenario encompassing:

• Building and tagging a container image.
• Publishing the image to a designated registry.
• Deploying the application to Kubernetes or OpenShift.
• Configuring application settings and credentials securely.
• Exposing the application for external access.
• Attaching persistent storage for data retention.
• Configuring access permissions using RBAC.
• Implementing health checks (startup, readiness, liveness).
• Scaling the application and performing version updates.
• Diagnosing and resolving an intentionally introduced failure.

Course Format

• Interactive lectures combined with technical discussions.
• Live instructor demonstrations of key concepts.
• Extensive hands-on exercises for practical application.
• Scenario-based administration and troubleshooting workshops.
• Practical work performed in real container, Kubernetes, and OpenShift environments.

Course Customization Options

• The course content can be adapted to align with the participant's existing infrastructure, cloud provider, and preferred container tooling.
• The emphasis on Docker, Kubernetes, and OpenShift topics can be adjusted based on the team's specific experience levels.
• Practical exercises can be tailored to reflect the organization's specific applications, deployment processes, and operational requirements.

Trademark Notice

OpenShift is a registered trademark of Red Hat, Inc. This independently developed training program is not affiliated with, endorsed by, or authorized by Red Hat.