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 deployment
• Difference between containers and virtual machines
• Container runtimes and engines
• The role of Docker, Kubernetes, and OpenShift
• Common architectures for container platforms
• Workflows for development, testing, and production

Working with Containers

• Running and managing containers
• The container lifecycle
• Starting, stopping, and removing containers
• Executing commands inside containers
• Utilizing environment variables
• Port mapping techniques
• Accessing 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 commands
• Leveraging image caching
• Strategies for reducing image size
• Building reproducible images

Container Registries

• Distinguishing between public and private registries
• Tagging and versioning images
• Pushing and pulling images
• Image authentication methods
• Image retention policies and cleanup
• Basic security considerations for images

Container Networking and Storage

• Core concepts of container networking
• Bridge networking implementation
• Port exposure strategies
• Facilitating container-to-container communication
• Using bind mounts and volumes
• Maintaining persistent container data
• Backup considerations for storage

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 of container orchestration
• Overview of Kubernetes architecture
• Components of the control plane
• Understanding worker nodes
• Functionality of the API server
• The role of the scheduler
• Controller operations
• Differentiating cluster state from desired state
• Interacting with the cluster using kubectl

Kubernetes Resources

• Pods
• ReplicaSets
• Deployments
• Namespaces
• Labels and annotations
• Selectors
• Declarative resource definitions
• YAML manifests

Deploying Applications

• Creating and managing Deployments
• Scaling workloads up or down
• Updating container images
• Implementing rolling updates
• Executing rollbacks
• Reviewing deployment history
• Restarting workloads
• Managing application replicas

Application Configuration

• Using ConfigMaps
• Utilizing Secrets
• Setting environment variables
• Managing configuration files
• Separating application code from configuration data
• Handling environment-specific settings

Resource Management

• Defining CPU and memory requests
• Setting CPU and memory limits
• Implementing resource quotas
• Configuring limit ranges
• Understanding scheduling implications
• Diagnosing failures related to resources

Hands-on Exercises

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

Day 3 – Kubernetes Networking, Storage, and Security

Kubernetes Networking

• The cluster networking model
• Pod-to-pod communication methods
• Service discovery mechanisms
• DNS resolution within the cluster
• ClusterIP services
• NodePort services
• LoadBalancer services
• Ingress concepts
• Patterns for application exposure

Network Policies

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

Persistent Storage

• Distinguishing ephemeral from persistent storage
• Volumes overview
• PersistentVolumes
• PersistentVolumeClaims
• StorageClasses
• Dynamic provisioning techniques
• Understanding access modes
• Reclaim policies for storage
• Utilizing storage for stateful applications

Kubernetes Access Control

• Concepts of authentication and authorization
• Role-Based Access Control (RBAC)
• Roles and ClusterRoles
• RoleBindings and ClusterRoleBindings
• Service accounts
• Implementing least-privilege access
• Inspecting effective permissions

Workload Security

• Security contexts explained
• Running containers as non-root users
• Managing Linux capabilities
• Implementing read-only filesystems
• Handling secrets securely
• Verifying image provenance
• Avoiding common configuration risks

Hands-on Exercises

• Exposing an application via Kubernetes services
• Configuring ingress rules
• Restricting traffic using network policies
• Provisioning persistent storage
• Configuring RBAC permissions
• Running a workload with an appropriate security context

Day 4 – Working with OpenShift Environments

Introduction to OpenShift

• OpenShift as a Kubernetes-based application platform
• Kubernetes resources within an OpenShift environment
• Architecture of an OpenShift cluster
• Difference between projects and namespaces
• Platform users and service accounts
• Navigating the web console
• Using the OpenShift CLI

Managing Projects and Access

• Creating and managing projects
• Assigning user permissions
• Project-level roles
• Administrative access controls
• Resource quotas in projects
• Limit ranges configuration
• Service accounts management
• Reviewing project resources

Deploying Applications

• Deploying container images in OpenShift
• Creating application workloads
• Managing deployments
• Scaling applications
• Updating application versions
• Performing rollbacks
• Managing application configuration
• Working with secrets in OpenShift

Application Exposure

• Understanding Services in OpenShift
• Configuring Routes
• TLS concepts and implementation
• Internal and external application access methods
• Managing hostnames and certificates
• Diagnosing route and service issues

Storage in OpenShift

• Persistent Volume Claims (PVCs)
• StorageClasses configuration
• Attaching storage to workloads
• Managing stateful workloads
• Storage access permissions
• Troubleshooting volume mounting issues

Scheduling and Node Management

• Labels and selectors in OpenShift
• Node selectors
• Taints and tolerations
• Affinity and anti-affinity concepts
• Workload placement strategies
• Cordoning and draining nodes
• Considerations for node maintenance

Hands-on Exercises

• Accessing an OpenShift environment
• Creating and configuring a project
• Deploying and exposing an application
• Configuring user and service-account access
• Attaching persistent storage
• Scaling and updating a running workload

Day 5 – Operations, Monitoring, and Troubleshooting

Platform Monitoring

• Monitoring cluster and application health
• Analyzing resource metrics
• Assessing node health
• Evaluating workload status
• Monitoring capacity and resource utilization
• Identifying performance constraints

Logging and Events

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

Health Checks

• Startup probes configuration
• Readiness probes setup
• Liveness probes implementation
• Designing effective health endpoints
• Diagnosing probe failures
• Preventing unnecessary application restarts

Troubleshooting Workloads

• Resolving pending pods
• Addressing image pull failures
• Investigating crash loops
• Fixing misconfigured environment variables
• Troubleshooting failed mounts
• Dealing with insufficient resources
• Resolving permission errors
• Diagnosing service and route connectivity problems
• Addressing DNS issues
• Investigating application startup failures

Operational Security

• Reviewing permissions regularly
• Proper service account usage
• Secure handling of credentials
• Image security best practices
• Ensuring network isolation
• Auditing platform access
• Applying the principle of least privilege

Maintenance and Lifecycle Management

• Conducting routine platform checks
• Performing node maintenance
• Considerations for application backups
• Backing up configurations
• Planning updates
• Managing changes effectively
• Testing updates in safe environments
• Planning for rollbacks
• Understanding disaster recovery concepts

Final Practical Workshop

Participants complete an end-to-end operational scenario:

• Building and tagging a container image.
• Publishing the image to a registry.
• Deploying the application to Kubernetes or OpenShift.
• Configuring application settings and credentials.
• Exposing the application externally.
• Attaching persistent storage.
• Configuring access permissions.
• Adding health checks.
• Scaling and updating the application.
• Diagnosing and resolving an introduced failure.

Course Format

• Interactive lectures and technical discussions.
• Instructor-led demonstrations.
• Extensive hands-on exercises.
• Scenario-based administration and troubleshooting workshops.
• Practical work in container, Kubernetes, and OpenShift environments.

Course Customization Options

• The course can be adapted to the participant's existing infrastructure, cloud provider, and container tooling.
• The balance between Docker, Kubernetes, and OpenShift topics can be adjusted according to the team's experience.
• Practical exercises can be tailored to the organization's 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.