Tutorial DevOps Docker Kubernetes AWS Developer Tools Cheat Sheet

Free DevOps Commands Cheat Sheet Online — Interactive Docker, Kubernetes, AWS CLI, Helm & Terraform Reference

· 16 min read

DevOps is the backbone of modern software delivery. Whether you are containerizing an application with Docker, orchestrating microservices on Kubernetes, provisioning cloud infrastructure with Terraform, managing releases with Helm, or scripting AWS operations from the terminal, the command line is where the work happens. Yet no single engineer memorizes every flag, every subcommand, and every edge case. Our free interactive DevOps commands cheat sheet solves this. It organizes more than seventy commands across six categories — Docker, Kubernetes, AWS CLI, Helm, Terraform, and common patterns — into a fast, searchable, filterable reference. Click any category tab to narrow the view, type in the search box to find a specific command, and copy any example to your clipboard with one click. Everything runs client-side in your browser. No signup, no data collection, no ads.

Why Developers Need a DevOps Cheat Sheet

The DevOps toolchain is vast and constantly evolving. Docker alone has hundreds of CLI options. kubectl covers every Kubernetes resource type across multiple API versions. AWS CLI supports hundreds of services, each with dozens of subcommands. Helm and Terraform bring their own DSLs and CLI conventions. Even experienced platform engineers regularly look up the exact syntax for a kubectl port-forward, the correct AWS S3 sync flags, or the Terraform workspace commands.

The problem is retrieval friction. When you are in the middle of debugging a failing pod or deploying an urgent hotfix, switching contexts to search documentation breaks concentration and introduces delays. A well-organized cheat sheet reduces that friction to seconds. An interactive cheat sheet goes further — it filters by category and search terms, surfacing exactly what you need without scrolling through irrelevant entries.

What This Cheat Sheet Covers

Our DevOps command reference is organized into six categories that map to real infrastructure and deployment workflows:

  • Docker — Running containers, managing images, networking, volumes, Docker Compose, and system cleanup.
  • Kubernetes (kubectl) — Pods, deployments, services, config maps, secrets, scaling, rollouts, and debugging.
  • AWS CLI — S3, EC2, Lambda, CloudFormation, IAM, RDS, CloudWatch, EKS, and CloudFront operations.
  • Helm — Installing, upgrading, rolling back, and managing chart releases and repositories.
  • Terraform — Init, plan, apply, destroy, workspace management, state inspection, and output handling.
  • Common Patterns — Multi-stage Dockerfiles, kubectl debug flows, S3 deploy scripts, Helm value overrides, and Terraform module structures.

Each command includes a one-line description, the exact syntax signature, a realistic example, and category tags. Destructive commands that remove data or infrastructure are marked with a warning badge so you know before you paste.

Docker Essentials

Docker is the de facto standard for containerizing applications. These commands form the foundation of every container workflow.

Running Containers

The docker run command creates and starts a new container from an image. It is the most common command you will use:

docker run -d -p 80:80 --name web nginx

This runs an Nginx container in detached mode (-d), maps port 80 on the host to port 80 in the container (-p 80:80), and names it web. The -d flag is essential for long-running services because it returns control of your terminal immediately.

To run a container interactively with a shell:

docker run -it ubuntu bash

To automatically remove a container when it exits:

docker run --rm hello-world

Managing Container Lifecycle

To list running containers:

docker ps

To see all containers including stopped ones:

docker ps -a

To stop a running container gracefully:

docker stop web

To remove a stopped container:

docker rm web

To force remove a running container:

docker rm -f web

Working with Images

To build an image from a Dockerfile:

docker build -t myapp:latest .

To pull an image from a registry:

docker pull nginx:alpine

To push an image to a registry:

docker push registry.example.com/myapp:v1

To remove an image:

docker rmi myapp:latest

Docker Compose

To start all services defined in a compose file:

docker compose up -d

To rebuild images before starting:

docker compose up -d --build

To stop and remove containers, networks, and volumes:

docker compose down -v

System Cleanup

Over time, Docker accumulates unused images, stopped containers, and build cache. Regular cleanup prevents disk space issues:

docker system prune -a --volumes

This removes stopped containers, unused networks, dangling images, and unused volumes. Use with caution in production environments.

Kubernetes with kubectl

Kubernetes is the dominant container orchestration platform. kubectl is the CLI that controls it. These commands cover the daily workflow of every platform engineer and SRE.

Inspecting Resources

To list pods in the default namespace:

kubectl get pods

To list pods in all namespaces with extra details:

kubectl get pods -A -o wide

To get detailed information about a specific pod:

kubectl describe pod myapp-7d9f4b8c5-x2z9a

To view recent events in the cluster:

kubectl get events --sort-by='.lastTimestamp'

Managing Deployments

To apply a configuration file:

kubectl apply -f deployment.yaml

To scale a deployment:

kubectl scale deployment myapp --replicas=5

To check rollout status:

kubectl rollout status deployment/myapp

To undo a failed rollout:

kubectl rollout undo deployment/myapp

Debugging Pods

To view pod logs:

kubectl logs -f myapp-7d9f4b8c5-x2z9a --tail=100

To execute a command inside a running pod:

kubectl exec -it myapp-7d9f4b8c5-x2z9a -- /bin/sh

To forward a local port to a pod or service:

kubectl port-forward svc/myapp 8080:80

Cluster Contexts

To see your current context:

kubectl config current-context

To switch to a different cluster context:

kubectl config use-context production

AWS CLI Essentials

The AWS CLI provides programmatic access to the full AWS ecosystem. These commands cover the most common operations for developers and DevOps engineers.

S3 Operations

To list buckets and objects:

aws s3 ls s3://mybucket --recursive

To copy a file to S3:

aws s3 cp ./file.txt s3://mybucket/

To sync a local directory with an S3 bucket:

aws s3 sync ./build s3://mybucket --delete

The --delete flag removes objects from the bucket that no longer exist locally, making this ideal for static site deployments.

Compute and Serverless

To list EC2 instances:

aws ec2 describe-instances --filters Name=tag:Env,Values=prod

To list Lambda functions:

aws lambda list-functions

To invoke a Lambda function:

aws lambda invoke --function-name myfunc out.json

Identity and Access

To verify your current identity:

aws sts get-caller-identity

To list IAM users:

aws iam list-users

EKS and CloudFront

To configure kubectl for an EKS cluster:

aws eks update-kubeconfig --name prod-cluster --region us-east-1

To invalidate a CloudFront distribution cache:

aws cloudfront create-invalidation --distribution-id E1234567890ABC --paths "/*"

Helm Package Management

Helm is the package manager for Kubernetes. It simplifies deploying complex applications through reusable charts.

Installing and Upgrading

To install a chart:

helm install myapp ./chart -f values.prod.yaml

To upgrade an existing release:

helm upgrade myapp ./chart --set image.tag=v2.1.0

To rollback to a previous revision:

helm rollback myapp 1

Managing Repositories

To add a chart repository:

helm repo add bitnami https://charts.bitnami.com/bitnami

To update all repositories:

helm repo update

To search for charts:

helm search hub nginx

Release Management

To list all releases:

helm list --all-namespaces

To uninstall a release:

helm uninstall myapp

To render templates locally without installing:

helm template myapp ./chart --debug

Terraform Infrastructure as Code

Terraform enables declarative infrastructure management. The workflow follows a predictable cycle: init, plan, apply.

Core Workflow

To initialize a Terraform working directory:

terraform init -backend-config=backend.hcl

To preview changes before applying:

terraform plan -out=tfplan -var-file=prod.tfvars

To apply the planned changes:

terraform apply tfplan

To destroy all managed infrastructure:

terraform destroy -auto-approve

Validation and Formatting

To validate configuration syntax:

terraform validate

To format all configuration files:

terraform fmt -recursive

Workspace Management

To create a new workspace:

terraform workspace new staging

To switch workspaces:

terraform workspace select staging

State and Outputs

To list resources in the state:

terraform state list

To view outputs:

terraform output -json

Common Patterns

Beyond individual commands, certain workflows come up repeatedly. Here are the patterns every DevOps engineer should have in their toolkit.

Multi-Stage Dockerfile

Multi-stage builds dramatically reduce final image size by separating the build environment from the runtime environment:

# Build stage
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Runtime stage
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80

Kubectl Debug Flow

When a pod fails, follow this systematic chain:

# 1. Inspect pod state and events
kubectl describe pod myapp-xxx

# 2. Check recent logs
kubectl logs myapp-xxx --tail=50

# 3. Open an interactive shell
kubectl exec -it myapp-xxx -- /bin/sh

# 4. Forward port for local testing
kubectl port-forward pod/myapp-xxx 8080:80

AWS S3 Deploy Script

A common pattern for deploying static sites to S3 with CloudFront invalidation:

aws s3 sync ./dist s3://mybucket --delete
aws cloudfront create-invalidation   --distribution-id E1234567890ABC   --paths "/*"

Helm Values Override

Override chart values using multiple mechanisms in priority order:

helm install myapp ./chart   -f values.yaml   -f values.prod.yaml   --set image.tag=v2.1.0   --set-json 'resources={"limits":{"cpu":"500m"}}'

Terraform Module Structure

A standard reusable module layout:

module/
  main.tf
  variables.tf
  outputs.tf
  versions.tf
  modules/
    vpc/
    rds/
  examples/
    complete/

How to Use the Interactive Cheat Sheet

Our DevOps Commands Cheat Sheet is designed for speed. When you open the tool, you see all seventy-five-plus commands organized into six color-coded categories. Click any category tab to filter. Type in the search box to filter by command name, description, or example. Click the copy icon on any card to copy the example command to your clipboard. Destructive commands that remove data or infrastructure are marked with an amber warning badge so you know before you paste.

The Control Room Console aesthetic uses a deep industrial background with category-colored accents: Docker cyan, Kubernetes blue, AWS orange, Helm navy, Terraform purple, and Patterns gray. It is optimized for long reference sessions with high-contrast syntax highlighting and a subtle grid texture that evokes a NASA mission control display.

Related Tools

Conclusion

DevOps commands are the lingua franca of modern infrastructure. Having a fast, searchable reference at your fingertips saves time, reduces context switching, and prevents costly mistakes. Our free interactive DevOps cheat sheet covers the commands you actually use — from Docker container management to Kubernetes pod debugging, from AWS S3 deployments to Helm chart upgrades, from Terraform planning to multi-stage Dockerfile optimization. It is 100% client-side, requires no signup, and works offline once loaded. Bookmark it and keep it open during your next deployment.

Found this useful? Check out our free developer tools or browse more articles.