Linux Foundation Kubernetes and Cloud Native Associate

A cluster is a control plane that holds desired state and nodes that carry it out. You meet the components and the objects used every day, and learn how labels and namespaces keep them organized.

• Control plane and worker node components
• Pods and why they are the unit of scheduling
• ReplicaSets and Deployments
• Services, labels and selectors
• Namespaces and the API’s resource model
• Desired state and control loops

You build An annotated map of the objects behind one running application.

You work with Kubernetes through its API, mostly with kubectl and YAML. You create, inspect and change objects, read cluster state, and see what routine administration involves.

• Declarative manifests and kubectl apply
• Inspecting objects with get and describe
• Namespaces and contexts
• Nodes, node conditions and maintenance
• Versions, upgrades and how clusters are installed
• Local clusters for learning

You build A small application defined in manifests, deployed to a local cluster and changed in place.

The scheduler decides where each pod runs. You learn how requests and limits shape that decision, how affinity and taints steer pods, and how autoscaling adds or removes capacity as load changes.

• How the scheduler picks a node
• Requests, limits and what they mean for stability
• Node selectors, affinity, taints and tolerations
• Scaling pods and scaling nodes
• Quotas and fair sharing between teams

You build A deployment with resource settings, placement rules and autoscaling, and a note on why each was chosen.

Pods need to find and reach one another. You see how every pod gets an address, how services and DNS give stable names, and how Ingress and the Gateway API bring outside traffic in.

• The Kubernetes network model
• Container network interface plugins
• Service types and cluster DNS
• Ingress and the Gateway API
• Network policies as pod-level firewalls

You build A diagram tracing a request from a browser to a pod, with each hop labeled.

Containers are disposable, but data is not. You learn how volumes, claims and storage classes separate what an application needs from what the infrastructure provides, and how StatefulSets keep identity steady.

• Volumes and why container files disappear
• PersistentVolumes and PersistentVolumeClaims
• Storage classes and dynamic provisioning
• StatefulSets and stable identity
• The container storage interface

You build A database deployment that keeps its data through a pod restart.

A cluster is shared infrastructure, so security is part of everyday use. You see how users and workloads are authenticated and authorized, how secrets are handled, and what a few basic controls protect.

• Authentication and RBAC in outline
• Secrets and their limits
• Pod security standards
• Image provenance and scanning
• The layers of cloud native security

You build A short security checklist for a first production workload, each item tied to a Kubernetes feature.

Things go wrong, and a calm routine finds the cause. You follow a failing pod through its status, events and logs, and learn the usual reasons that workloads do not start, keep restarting or receive no traffic.

• Reading pod status and phases
• Events and describe output
• Container logs and previous logs
• Common failures: image pulls, crashes, probes, resources
• Checking a service that has no backends

You build A troubleshooting flowchart, tested against three broken deployments.

Applications reach a cluster through a pipeline, not a laptop. You learn how packaging with Helm, continuous integration and delivery, and GitOps fit together, and how debugging works once a release is live.

• Application delivery in a cloud native workflow
• Packaging with Helm and Kustomize
• Continuous integration and continuous delivery
• GitOps and declarative delivery
• Rolling updates and rollback
• Debugging a release in a live cluster

You build A delivery diagram for one application, from commit to running pod, naming the tool at each step.

Cloud native is a way of building systems that expect failure and change. You learn the principles behind it, the three signals of observability, and the standards and tools that implement them.

• Microservices, twelve-factor ideas and resilience
• Autoscaling and serverless patterns
• Logs, metrics and traces
• Prometheus and OpenTelemetry in outline
• Service mesh in outline
• Reading a health dashboard

You build An architecture sketch of a cloud native application with its signals and dashboards marked.

Kubernetes is one project in a large, open ecosystem. You learn how the CNCF and its maturity levels work, how special interest groups steer projects, and how to follow and contribute to open source.

• The CNCF and what it hosts
• Sandbox, incubating and graduated projects
• Special interest groups and how decisions are made
• Reading the cloud native landscape
• Open governance and contributing

You build A shortlist of landscape projects for one platform need, with maturity and trade-offs noted.

Follow a single application through everything you have learned: containerize it, deploy it, expose it, secure it, observe it and troubleshoot it. You explain each decision in plain terms, as you would to a new teammate.

• Describing the application and its needs
• Choosing Kubernetes objects for each part
• Placing, exposing and securing it
• Adding observability and delivery
• Explaining the design to a newcomer

You build A written walkthrough of one application on Kubernetes, with diagrams, that a newcomer could follow.