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 versus container-based deployment
• Differences between containers and virtual machines
• Understanding container runtimes and container engines
• The specific roles of Docker, Kubernetes, and OpenShift
• Overview of common container platform architectures
• Workflows for development, testing, and production phases

Working with Containers

• Running and managing containers
• Understanding the container lifecycle
• Starting, stopping, and removing containers
• Executing commands inside running containers
• Managing environment variables
• Configuring port mapping
• Accessing and analyzing container logs
• Inspecting resource usage and processes

Building Container Images

• Understanding image structure and layers
• Creating Dockerfiles and Containerfiles
• Selecting appropriate base images
• Incorporating application dependencies
• Configuring entry points and default commands
• Leveraging image caching for efficiency
• Techniques to reduce image size
• Strategies for building reproducible images

Container Registries

• Differences between public and private registries
• Tagging and versioning container images
• Pushing and pulling images from registries
• Managing image authentication
• Image retention policies and cleanup procedures
• Basic considerations for image security

Container Networking and Storage

• Fundamentals of container networking concepts
• Understanding bridge networking
• Exposing ports to the outside world
• Enabling communication between containers
• Using bind mounts and volumes for storage
• Managing persistent container data
• Strategies for backup considerations

Hands-on Exercises

• Running and inspecting containers in practice
• Building an application image from scratch
• Configuring ports and environment variables
• Publishing an image to a registry
• Storing persistent data outside the container boundary

Day 2 – Kubernetes Architecture and Workloads

Kubernetes Fundamentals

• The purpose and benefits of container orchestration
• Overview of Kubernetes architecture
• Components of the control plane
• Understanding worker nodes
• The role of the API server
• How the scheduler functions
• Function of controllers
• Concepts of cluster state versus desired state
• Interacting with the cluster using kubectl

Kubernetes Resources

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

Deploying Applications

• Creating and managing Deployments
• Scaling workloads up or down
• Updating container images within deployments
• Executing rolling updates
• Performing rollbacks to previous versions
• Accessing deployment history
• Restarting workloads as needed
• Managing the number of application replicas

Application Configuration

• Using ConfigMaps for configuration data
• Storing sensitive data in Secrets
• Passthrough of environment variables
• Mounting configuration files
• Separating application code from configuration settings
• Managing settings specific to different environments

Resource Management

e>
• Defining CPU and memory requests
• Setting CPU and memory limits
• Implementing resource quotas per namespace
• Applying limit ranges for default constraints
• Understanding implications for scheduling
• Diagnosing failures caused by resource issues

Hands-on Exercises

• Deploying a containerized application on Kubernetes
• 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 to workloads

Day 3 – Kubernetes Networking, Storage, and Security

Kubernetes Networking

• The cluster networking model
• Facilitating pod-to-pod communication
• Implementing service discovery
• DNS resolution inside the cluster
• Understanding ClusterIP services
• Utilizing NodePort services
• Leveraging LoadBalancer services
• Core concepts of Ingress
• 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

• Distinguishing ephemeral versus persistent storage
• Working with standard Volumes
• Managing PersistentVolumes (PVs)
• Using PersistentVolumeClaims (PVCs)
• Defining and utilizing StorageClasses
• Enabling dynamic provisioning
• Understanding access modes for volumes
• Configuring reclaim policies
• Implementing storage solutions for stateful applications

Kubernetes Access Control

• Foundations of authentication and authorization
• Understanding Role-Based Access Control (RBAC)
• Defining Roles and ClusterRoles
• Binding roles via RoleBindings and ClusterRoleBindings
• Managing Service Accounts
• Enforcing least-privilege access principles
• Inspecting effective permissions for users and accounts

Workload Security

• Configuring security contexts
• Running containers as non-root users
• Managing Linux capabilities
• Implementing read-only filesystems
• Best practices for Secret handling
• Verifying image provenance
• Awareness of common configuration risks

Hands-on Exercises

• Exposing an application via Kubernetes services
• Configuring Ingress resources
• Restricting traffic flows using network policies
• Provisioning persistent storage for a workload
• Configuring RBAC permissions for users and groups
• Running a workload with an appropriate security context

Day 4 – Working with OpenShift Environments

Introduction to OpenShift

• OpenShift as a Kubernetes-based application platform
• Mapped Kubernetes resources within an OpenShift context
• Architecture of an OpenShift cluster
• Differences between Projects and Namespaces in OpenShift
• Managing platform users and service accounts
• Navigating the OpenShift web console
• Using the OpenShift CLI (oc) effectively

Managing Projects and Access

• Creating and managing OpenShift projects
• Assigning user permissions within projects
• Understanding project-level roles
• Granting administrative access
• Setting resource quotas per project
• Applying limit ranges for constraints
• Working with service accounts in projects
• Reviewing resources within a specific project

Deploying Applications in OpenShift

• Deploying container images into OpenShift
• Creating application workloads using BuildConfigs or Source-to-Image
• Managing DeploymentConfig objects
• Scaling applications via the console or CLI
• Updating application versions
• Performing rollbacks in OpenShift deployments
• Managing application configuration data
• Handling secrets within OpenShift

Application Exposure in OpenShift

• Understanding Services in OpenShift
• Creating and managing Routes for external access
• TLS concepts and certificate management in OpenShift
• Differentiating internal versus external application access
• Managing hostnames and certificates
• Troubleshooting route and service connectivity issues

Storage in OpenShift

• Utilizing Persistent Volume Claims (PVCs)
• Configuring StorageClasses
• Attaching storage to workloads
• Managing stateful workloads with storage
• Setting storage access permissions
• Troubleshooting volume mounting failures

Scheduling and Node Management

e>
• Advanced use of labels and selectors
• Configuring node selectors for specific nodes
• Understanding taints and tolerations
• Implementing affinity and anti-affinity rules
• Strategies for workload placement
• Cordoning and draining nodes for maintenance
• Considerations for node maintenance tasks

Hands-on Exercises

• Accessing an OpenShift environment via CLI or Console
• Creating and configuring a new project
• Deploying and exposing an application
• Configuring access for users and service accounts
• Attaching persistent storage to a workload
• Scaling and updating a running workload

Day 5 – Operations, Monitoring, and Troubleshooting

Platform Monitoring

• Monitoring the health of clusters and applications
• Analyzing resource metrics (CPU, Memory)
• Checking node health status
• Reviewing workload status indicators
• Evaluating capacity and resource utilization
• Identifying performance bottlenecks and constraints

Logging and Events

• Accessing container logs
• Retrieving pod logs
• Viewing previous container logs for debugging
• Analyzing Kubernetes events
• Interpreting application and platform messages
• Filtering and interpreting operational data effectively

Health Checks

• Implementing startup probes
• Configuring readiness probes
• Setting up liveness probes
• Designing useful health check endpoints
• Diagnosing probe failures and misconfigurations
• Preventing unnecessary application restarts due to false positives

Troubleshooting Workloads

e>
• Resolving pending pod states
• Debugging image pull failures
• Investigating crash loops
• Correcting misconfigured environment variables
• Fixing failed volume mounts
• Addressing insufficient resource errors
• Resolving permission denied errors
• Troubleshooting service and route connectivity problems
• Diagnosing DNS resolution issues
• Debugging application startup failures

Operational Security

• Regularly reviewing permissions and roles
• Auditing service account usage
• Secure handling of credentials and secrets
• Adhering to image security best practices
• Ensuring network isolation between components
• Conducting platform access audits
• Applying the principle of least privilege consistently

Maintenance and Lifecycle Management

• Performing routine platform health checks
• Scheduling node maintenance windows
• Considerations for application data backups
• Backing up platform configurations
• Planning update cycles
• Managing changes through proper channels
• Testing updates in non-production environments
• Planning rollback strategies
• Understanding disaster recovery concepts

Final Practical Workshop

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

• Build and tag a container image.
• Publish the image to a designated registry.
• Deploy the application to either Kubernetes or OpenShift.
• Configure application settings and inject credentials.
• Expose the application to external users.
• Attach persistent storage for data retention.
• Configure access permissions for security.
• Add health checks to ensure reliability.
• Scale and update the application dynamically.
• Diagnose and resolve an intentionally introduced failure.

Course Format

• Interactive lectures coupled with technical discussions.
• Instructor-led demonstrations of key concepts.
• Extensive hands-on exercises for skill building.
• Scenario-based administration and troubleshooting workshops.
• Practical work within 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 balance between Docker, Kubernetes, and OpenShift topics can be adjusted to match the team's current experience level.
• Practical exercises can be tailored to reflect the organization's specific applications, deployment processes, and operational requirements.

Trademark Notice

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