React
React Native
Node.js
Python
Rust
PostgreSQL
Solana
Claude
AI Agents
Go
Containers

Containers SME Cookbook

Perguntas frequentes

Seções

Fundamentos de Containers e Docker

What a Container Really Is Container Basics Containers vs Virtual Machines OCI Image & Runtime Specs Linux Namespaces & cgroups Immutable Infrastructure Principle Container Fundamentals Best Practices

How the Docker Engine Works Docker Engine Basics Essential CLI Commands Docker Contexts Docker Desktop vs Linux Engine Engine Configuration Docker Engine Best Practices

How a Dockerfile Becomes an Image Dockerfile Basics How Image Layers & Union Filesystems Work Multi-Stage Builds BuildKit & Cache Mounts buildx & Multi-Arch Images `.dockerignore` & Build Context Non-Root Users in Images Distroless & Minimal Bases Dockerfiles Best Practices

Why the Software Supply Chain Matters Registries Basics Tagging & Immutability Registry Authentication cosign & Image Signing SBOM Generation Supply Chain Best Practices

The Compose Model: Declaring a Local Stack Compose Basics Compose for Local Dev Profiles & Overrides Compose vs Kubernetes Gap Compose Best Practices

What Actually Runs Your Containers Runtimes Basics containerd & crictl CRI-O runc & Low-Level OCI Runtimes Best Practices

Dev/Prod Parity as a Mental Model Local Dev Basics Bind Mounts vs Image Rebuild Dev Containers Hot Reload in Containers Local Dev Best Practices

How Containers Get Networking and Storage Docker Networking Basics User-Defined Networks Volumes & Bind Mounts Storage Permissions Pitfalls Networking & Storage Best Practices

Ferramentas, Qualidade e Governança de Imagens

Where Docker Fits in a Repository Repo Layout Basics Monorepo Build Contexts Base Image Internal Registry Project Setup Best Practices

What an Image Build Pipeline Is For Image CI Basics GitHub Actions & buildx Remote Cache Provenance & SLSA Build Pipeline Best Practices

Why Images Need Their Own Quality Gates Linting Basics dive & Image Efficiency Container Structure Tests Smoke Tests After Build Linting Best Practices

The Container Vulnerability Lifecycle Vulnerability Basics Base Image Pinning by Digest Exception Process Minimal Attack Surface Image Policy Best Practices

Why Rules Beat Tribal Knowledge Containers Rules Checklist Dockerfile Rules Kubernetes Manifest Rules ADR Template Containers Rules Best Practices

Arquitetura e Design de Plataforma

What a Platform (IDP) Actually Is Platform Architecture Basics Golden Paths Multi-Cluster Topology Build vs Buy Managed K8s Platform Architecture Best Practices

How Multi-Tenancy Works in a Cluster Tenancy Basics Environment Separation Resource Quotas & LimitRanges Noisy Neighbor Controls Tenancy Best Practices

Separating Config and Secrets from Images Config Basics Secrets Management External Secrets Operator Config Reload Patterns Configuration Best Practices

How Kubernetes Thinks About Storage K8s Storage Basics CSI Drivers Stateful Data on Kubernetes Backup PVs Storage Architecture Best Practices

How Misconfiguration Becomes Outage Defect Scenarios Basics :latest in Production Probe Misconfiguration Resource Limit OOMKilled Defect Scenarios Best Practices

Kubernetes - Núcleo e Workloads

What Kubernetes Is and Why It Exists Kubernetes Basics Declarative vs Imperative kubectl Essentials API Objects & Reconciliation Labels & Selectors Kubernetes Fundamentals Best Practices

What a Pod Represents Pods Basics Why the Pod, Not the Container, Is the Unit Container Spec Liveness, Readiness & Startup Probes Requests & Limits Init & Sidecar Containers Pod Disruption Budgets Pods Best Practices

How Kubernetes Keeps N Copies Running Deployments Basics How Rolling Updates Actually Work Rolling Update Parameters Rollback Blue/Green & Canary Deployments Best Practices

Run-to-Completion vs Long-Running Work Jobs Basics CronJob Patterns Indexed & Parallel Jobs Jobs Best Practices

When Identity and Node Placement Matter StatefulSets Basics Headless Services + StatefulSets DaemonSets StatefulSets Best Practices

The Three Axes of Kubernetes Scaling Autoscaling Basics Horizontal Pod Autoscaler Cluster Autoscaler Vertical Pod Autoscaler KEDA Event-Driven Scaling Autoscaling Best Practices

A Map of the Kubernetes Machinery Kubernetes Internals Basics The Reconciliation Loop Explained Control Plane Internals etcd, Raft & Cluster State The Object Model: Spec, Status & resourceVersion Watches, Informers & the List-Watch Pattern Why Kubernetes Is a Distributed System Kubernetes Internals Best Practices

What Scheduling Is and Why It's Hard Scheduling Basics How the Scheduler Decides nodeSelector, Node Affinity & Anti-Affinity Taints & Tolerations Topology Spread Constraints Pod Priority, Preemption & the Descheduler Scheduling Best Practices

Extending Kubernetes: The Big Idea CRDs & Operators Basics The Operator Pattern Explained How Controllers Work (controller-runtime)CRD Design & Versioning Using Operators in Production Operators vs Helm vs Plain Manifests CRDs & Operators Best Practices

Kubernetes - Rede e Service Mesh

Why Pods Need Services Services Basics Life of a Request ClusterIP & Headless NodePort & LoadBalancer EndpointSlices Services Best Practices

How External Traffic Reaches Your Pods Ingress Basics Ingress Controllers TLS Certificates Gateway API Ingress Best Practices

Why the Cluster Network Is Open by Default Network Policies Basics The Kubernetes Network Model Default-Deny Stance CNI Comparison DNS Egress Policies Network Policies Best Practices

How Services Find Each Other DNS Basics CoreDNS Configuration ExternalName & Split Horizon DNS Best Practices

What a Service Mesh Adds - and Costs Service Mesh Basics Linkerd Istio Mesh vs No-Mesh ADR Service Mesh Best Practices

Segurança, Políticas e Observabilidade

How Kubernetes Decides Who Can Do What RBAC Basics Service Accounts OIDC & SSO for kubectl RBAC Auditing RBAC Best Practices

The Layers of Pod Security Pod Security Basics Why Containers Aren’t a Security Boundary securityContext seccomp & AppArmor Pod Security Best Practices

Where Kubernetes Enforces Your Rules Admission Basics Kyverno Policies OPA Gatekeeper Policy Testing Admission Best Practices

The Three Pillars of Cluster Observability Observability Basics metrics-server & HPA Prometheus & Grafana Log Aggregation OpenTelemetry Collectors Observability Best Practices

Shift-Left vs Runtime Security Scanning Basics Runtime Security eBPF Observability Runtime Protection Best Practices

Entrega, GitOps e Operações

Templating vs Overlaying Manifests Helm Basics Chart Design Kustomize Helm vs Kustomize ADR Helm Best Practices

What GitOps Actually Means GitOps Basics Argo CD Flux Drift Detection GitOps Best Practices

From Commit to Running Pod Deploy Pipeline Basics Image Updater Bots Progressive Delivery CI/CD Best Practices

How a Living Cluster Gets Upgraded Upgrades Basics Node Image Updates Cordon & Drain Surge Node Pools Upgrade Best Practices

Why One Cluster Isn't Always Enough Multi-Cluster Basics Cluster API Fleet GitOps DR Cluster Standby Multi-Cluster Best Practices

Kubernetes em Nuvem e Ecossistema

What "Managed" Does and Doesn't Cover Managed K8s Basics Amazon EKS Google GKE Azure AKS Cloud Selection ADR Managed K8s Best Practices

The Platform Engineer's Toolkit, Conceptually Platform Tools Basics k9s & stern cert-manager external-dns Velero Platform Tools Best Practices

Why Kubernetes Costs What It Does Kubernetes Cost Basics Right-Sizing Requests & Limits Karpenter Spot & Interruptible Nodes Cost Visibility (OpenCost / Kubecost)Cost Optimization Best Practices

What a Packaged SME Skill Is Agent Skills Basics Dockerfile Review Skill Kubernetes Manifest Skill Incident Triage Skill Agent Skills Best Practices

Git as the Platform's Control Plane Git for Platform Work Basics Policy Bots in PRs Git Best Practices

Why Platform Work Drops to the Node Linux CLI Basics crictl & ctr nsenter & cgroup tools CLI Best Practices

Making App Devs Cluster-Safe Onboarding Basics Developer Self-Service Skills Matrix Pairing on Manifest PRs Team & Onboarding Best Practices

Craft de Tech Lead: Entrega, Liderança e Longevidade

How to Think During a Cluster Incident Incident Basics CrashLoopBackOff Triage OOMKilled & CPU Throttling ImagePullBackOff & Registry Outages Node NotReady & CNI Failures Incident Response Best Practices

Treating the Platform as a Product Platform Delivery Basics Change Windows Platform SLOs Error Budgets for Platform Platform Delivery Best Practices

Leading a Platform, Not Just Running It Tech Lead Basics on Platforms Golden Path Governance Manifest Review Standards Build vs Buy Add-Ons Technical Leadership Best Practices

Translating Clusters into Business Language Stakeholder Basics Quota & Capacity Requests Risk Communication Stakeholder Best Practices

How to Read a Reference Architecture Reference: Multi-Tenant EKS Platform Reference: Worker-Heavy Cluster Reference: Regulated Environment Before/After: Compose → EKS Migration Before/After: Ingress → Gateway API Case Studies Best Practices

Why Governance Scales Where Heroics Don't Governance Basics Kubernetes Version Policy API Deprecation Tracking Extension & Add-On Governance Career Growth: Platform Engineer → Staff Governance Best Practices

/

/

© 2026 @csjcode|SystemsArchitect.io: Cloud Systems Tools|Termos

Recurso educacional independente e não oficial. Sem afiliação, endosso ou patrocínio dos proprietários ou responsáveis pelas marcas.

Buscar na documentação

Busque em todas as páginas da documentação

Containers SME/Tags/Kubernetes

#Kubernetes265 pages

Pages tagged Kubernetes across 42 sections.

Admission & Policy

Admission Basics Admission Best Practices Kyverno Policies OPA Gatekeeper Policy Testing Where Kubernetes Enforces Your Rules

Agent Skills Basics Agent Skills Best Practices Dockerfile Review Skill Incident Triage Skill Kubernetes Manifest Skill What a Packaged SME Skill Is

Autoscaling Basics Autoscaling Best Practices Cluster Autoscaler Horizontal Pod Autoscaler KEDA Event-Driven Scaling The Three Axes of Kubernetes Scaling Vertical Pod Autoscaler

Before/After: Compose → EKS Migration Before/After: Ingress → Gateway API Case Studies Best Practices How to Read a Reference Architecture Reference: Multi-Tenant EKS Platform Reference: Regulated Environment Reference: Worker-Heavy Cluster

CI/CD Best Practices Deploy Pipeline Basics From Commit to Running Pod Image Updater Bots Progressive Delivery

Log Aggregation metrics-server & HPA Observability Basics Observability Best Practices OpenTelemetry Collectors Prometheus & Grafana The Three Pillars of Cluster Observability

Upgrades & Nodes

Cordon & Drain How a Living Cluster Gets Upgraded Node Image Updates Surge Node Pools Upgrade Best Practices Upgrades Basics

Config & Secrets

Config Basics Config Reload Patterns Configuration Best Practices External Secrets Operator Secrets Management Separating Config and Secrets from Images

Cost Optimization Best Practices Cost Visibility (OpenCost / Kubecost)Karpenter Kubernetes Cost Basics Right-Sizing Requests & Limits Spot & Interruptible Nodes Why Kubernetes Costs What It Does

CRDs & Operators

CRD Design & Versioning CRDs & Operators Basics CRDs & Operators Best Practices Extending Kubernetes: The Big Idea How Controllers Work (controller-runtime)Operators vs Helm vs Plain Manifests The Operator Pattern Explained Using Operators in Production

Blue/Green & Canary Deployments Basics Deployments Best Practices How Kubernetes Keeps N Copies Running How Rolling Updates Actually Work Rollback Rolling Update Parameters

DNS & Discovery

CoreDNS Configuration DNS Basics DNS Best Practices ExternalName & Split Horizon How Services Find Each Other

Delivery & SLOs

Change Windows Error Budgets for Platform Platform Delivery Basics Platform Delivery Best Practices Platform SLOs Treating the Platform as a Product

Git as the Platform's Control Plane Git Best Practices Git for Platform Work Basics Policy Bots in PRs

Argo CD Drift Detection Flux GitOps Basics GitOps Best Practices What GitOps Actually Means

Helm & Kustomize

Chart Design Helm Basics Helm Best Practices Helm vs Kustomize ADR Kustomize Templating vs Overlaying Manifests

Incident Response

CrashLoopBackOff Triage How to Think During a Cluster Incident ImagePullBackOff & Registry Outages Incident Basics Incident Response Best Practices Node NotReady & CNI Failures OOMKilled & CPU Throttling

Ingress & Gateway API

Gateway API How External Traffic Reaches Your Pods Ingress Basics Ingress Best Practices Ingress Controllers TLS Certificates

Jobs & CronJobs

CronJob Patterns Indexed & Parallel Jobs Jobs Basics Jobs Best Practices Run-to-Completion vs Long-Running Work

Kubernetes Fundamentals

API Objects & Reconciliation Declarative vs Imperative kubectl Essentials Kubernetes Basics Kubernetes Fundamentals Best Practices Labels & Selectors What Kubernetes Is and Why It Exists

A Map of the Kubernetes Machinery Control Plane Internals etcd, Raft & Cluster State Kubernetes Internals Basics Kubernetes Internals Best Practices The Object Model: Spec, Status & resourceVersion The Reconciliation Loop Explained Watches, Informers & the List-Watch Pattern Why Kubernetes Is a Distributed System

CLI Best Practices crictl & ctr Linux CLI Basics nsenter & cgroup tools Why Platform Work Drops to the Node

Amazon EKS Azure AKS Cloud Selection ADR Google GKE Managed K8s Basics Managed K8s Best Practices What "Managed" Does and Doesn't Cover

Multi-Cluster & Fleet

Cluster API DR Cluster Standby Fleet GitOps Multi-Cluster Basics Multi-Cluster Best Practices Why One Cluster Isn't Always Enough

Network Policies & CNI

CNI Comparison Default-Deny Stance DNS Egress Policies Network Policies Basics Network Policies Best Practices The Kubernetes Network Model Why the Cluster Network Is Open by Default

Platform Architecture

Build vs Buy Managed K8s Golden Paths Multi-Cluster Topology Platform Architecture Basics Platform Architecture Best Practices What a Platform (IDP) Actually Is

Defect Scenarios

:latest in Production Defect Scenarios Basics Defect Scenarios Best Practices How Misconfiguration Becomes Outage Probe Misconfiguration Resource Limit OOMKilled

cert-manager external-dns k9s & stern Platform Tools Basics Platform Tools Best Practices The Platform Engineer's Toolkit, Conceptually Velero

Pod Security Basics Pod Security Best Practices seccomp & AppArmor securityContext The Layers of Pod Security Why Containers Aren’t a Security Boundary

Container Spec Init & Sidecar Containers Liveness, Readiness & Startup Probes Pod Disruption Budgets Pods Basics Pods Best Practices Requests & Limits What a Pod Represents Why the Pod, Not the Container, Is the Unit

Product & Stakeholders

Quota & Capacity Requests Risk Communication Stakeholder Basics Stakeholder Best Practices Translating Clusters into Business Language

How Kubernetes Decides Who Can Do What OIDC & SSO for kubectl RBAC Auditing RBAC Basics RBAC Best Practices Service Accounts

How the Scheduler Decides nodeSelector, Node Affinity & Anti-Affinity Pod Priority, Preemption & the Descheduler Scheduling Basics Scheduling Best Practices Taints & Tolerations Topology Spread Constraints What Scheduling Is and Why It's Hard

Scanning & Runtime

eBPF Observability Runtime Protection Best Practices Runtime Security Scanning Basics Shift-Left vs Runtime Security

Istio Linkerd Mesh vs No-Mesh ADR Service Mesh Basics Service Mesh Best Practices What a Service Mesh Adds - and Costs

Services & kube-proxy

ClusterIP & Headless EndpointSlices Life of a Request NodePort & LoadBalancer Services Basics Services Best Practices Why Pods Need Services

Standards & Governance

API Deprecation Tracking Career Growth: Platform Engineer → Staff Extension & Add-On Governance Governance Basics Governance Best Practices Kubernetes Version Policy Why Governance Scales Where Heroics Don't

StatefulSets & DaemonSets

DaemonSets Headless Services + StatefulSets StatefulSets Basics StatefulSets Best Practices When Identity and Node Placement Matter

Storage Architecture

Backup PVs CSI Drivers How Kubernetes Thinks About Storage K8s Storage Basics Stateful Data on Kubernetes Storage Architecture Best Practices

Team & Onboarding

Developer Self-Service Making App Devs Cluster-Safe Onboarding Basics Pairing on Manifest PRs Skills Matrix Team & Onboarding Best Practices

Tech Leadership

Build vs Buy Add-Ons Golden Path Governance Leading a Platform, Not Just Running It Manifest Review Standards Tech Lead Basics on Platforms Technical Leadership Best Practices

Workload & Tenancy

Environment Separation How Multi-Tenancy Works in a Cluster Noisy Neighbor Controls Resource Quotas & LimitRanges Tenancy Basics Tenancy Best Practices

Related tags

Guide Workloads Explainer Best Practices Cloud Native Basics Operations Networking