Kubernetes

https://kubernetes.io/docs
Admin
Kubernetes is an open-source system for automating deployment, scaling, and management of...
Tokens:5,016,143
Snippets:34,326
Trust Score:9.9
Update:2 days ago
Show doc for...
Tokens:
Raw
### kubectl explain usage examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_explain/

Examples showing how to get documentation for resources and fields, use recursive listing with depth limits, specify API versions, and change output format.

```bash
  # Get the documentation of the resource and its fields
  kubectl explain pods
  
  # Get all the fields in the resource
  kubectl explain pods --recursive
  
  # Get fields in the resource up to a specific recursive depth
  kubectl explain pods --recursive --max-depth=2
  
  # Get the explanation for deployment in supported api versions
  kubectl explain deployments --api-version=apps/v1
  
  # Get the documentation of a specific field of a resource
  kubectl explain pods.spec.containers
  
  # Get the documentation of resources in different format
  kubectl explain deployment --output=plaintext-openapiv2
```

--------------------------------

### kubectl get examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_get/

A collection of common kubectl get usage examples, including listing pods, deployments, and other resources with various output formats and filters.

```shell
  # List all pods in ps output format
  kubectl get pods
  
  # List all pods in ps output format with more information (such as node name)
  kubectl get pods -o wide
  
  # List a single replication controller with specified NAME in ps output format
  kubectl get replicationcontroller web
  
  # List deployments in JSON output format, in the "v1" version of the "apps" API group
  kubectl get deployments.v1.apps -o json
  
  # List a single pod in JSON output format
  kubectl get -o json pod web-pod-13je7
  
  # List a pod identified by type and name specified in "pod.yaml" in JSON output format
  kubectl get -f pod.yaml -o json
  
  # List resources from a directory with kustomization.yaml - e.g. dir/kustomization.yaml
  kubectl get -k dir/
  
  # Return only the phase value of the specified pod
  kubectl get -o template pod/web-pod-13je7 --template={{.status.phase}}
  
  # List resource information in custom columns
  kubectl get pod test-pod -o custom-columns=CONTAINER:.spec.containers[0].name,IMAGE:.spec.containers[0].image
  
  # List all replication controllers and services together in ps output format
  kubectl get rc,services
  
  # List one or more resources by their type and names
  kubectl get rc/web service/frontend pods/web-pod-13je7
  
  # List the 'status' subresource for a single pod
  kubectl get pod web-pod-13je7 --subresource status
  
  # List all deployments in namespace 'backend'
  kubectl get deployments.apps --namespace backend
  
  # List all pods existing in all namespaces
  kubectl get pods --all-namespaces
```

--------------------------------

### kubectl run examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_run/

A collection of examples demonstrating common use cases for `kubectl run`, such as starting pods with specific images, setting environment variables, labels, ports, dry-run, overrides, and custom commands.

```bash
  # Start a nginx pod
  kubectl run nginx --image=nginx
  
  # Start a hazelcast pod and let the container expose port 5701
  kubectl run hazelcast --image=hazelcast/hazelcast --port=5701
  
  # Start a hazelcast pod and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container
  kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"
  
  # Start a hazelcast pod and set labels "app=hazelcast" and "env=prod" in the container
  kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"
  
  # Dry run; print the corresponding API objects without creating them
  kubectl run nginx --image=nginx --dry-run=client
  
  # Start a nginx pod, but overload the spec with a partial set of values parsed from JSON
  kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'
  
  # Start a busybox pod and keep it in the foreground, don't restart it if it exits
  kubectl run -i -t busybox --image=busybox --restart=Never
  
  # Start the nginx pod using the default command, but use custom arguments (arg1 .. argN) for that command
  kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>
  
  # Start the nginx pod using a different command and custom arguments
  kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>
```

--------------------------------

### kubectl get and describe commands for basic resource viewing

Source: https://kubernetes.io/docs/reference/kubectl/quick-reference/

Use these commands to list resources, get detailed information, and output in YAML format. Includes examples for services, pods, deployments, and nodes.

```bash
# Get commands with basic output
kubectl get services                          # List all services in the namespace
kubectl get pods --all-namespaces             # List all pods in all namespaces
kubectl get pods -o wide                      # List all pods in the current namespace, with more details
kubectl get deployment my-dep                 # List a particular deployment
kubectl get pods                              # List all pods in the namespace
kubectl get pod my-pod -o yaml                # Get a pod's YAML

# Describe commands with verbose output
kubectl describe nodes my-node
kubectl describe pods my-pod
```

--------------------------------

### kubectl create examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/

Examples showing how to create a pod from a file, from stdin, and with editing.

```bash
  # Create a pod using the data in pod.json
  kubectl create -f ./pod.json
  
  # Create a pod based on the JSON passed into stdin
  cat pod.json | kubectl create -f -
  
  # Edit the data in registry.yaml in JSON then create the resource using the edited data
  kubectl create -f registry.yaml --edit -o json
```

--------------------------------

### Start a minikube cluster with minikube start

Source: https://kubernetes.io/docs/tutorials/hello-minikube/

Creates a single-Node cluster where the Node acts as both control plane and worker Node. Requires minikube installed per Step 1 of the minikube start guide.

```shell
minikube start
```

--------------------------------

### kubectl apply examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_apply/

Examples of applying configurations from files, directories, stdin, and glob patterns, including alpha --prune usage.

```bash
  # Apply the configuration in pod.json to a pod
  kubectl apply -f ./pod.json
  
  # Apply resources from a directory containing kustomization.yaml - e.g. dir/kustomization.yaml
  kubectl apply -k dir/
  
  # Apply the JSON passed into stdin to a pod
  cat pod.json | kubectl apply -f -
  
  # Apply the configuration from all files that end with '.json'
  kubectl apply -f '*.json'
  
  # Note: --prune is still in Alpha
  # Apply the configuration in manifest.yaml that matches label app=nginx and delete all other resources that are not in the file and match label app=nginx
  kubectl apply --prune -f manifest.yaml -l app=nginx
  
  # Apply the configuration in manifest.yaml and delete all the other config maps that are not in the file
  kubectl apply --prune -f manifest.yaml --all --prune-allowlist=core/v1/ConfigMap
```

--------------------------------

### Install Kompose using go get

Source: https://kubernetes.io/docs/tasks/configure-pod-container/translate-compose-kubernetes/

Install Kompose from the master branch with the latest development changes using go get.

```sh
go get -u github.com/kubernetes/kompose
```

--------------------------------

### Watch Semantics for Resource Versions

Source: https://kubernetes.io/docs/reference/using-api/api-concepts/

Describes how the resourceVersion parameter affects watch behavior, including three modes: Get State and Start at Most Recent, Get State and Start at Any, and Start at Exact.

```APIDOC
## Watch Semantics

### Description
When making a watch request, the `resourceVersion` parameter determines the starting point and initial state behavior. The semantics vary based on whether `resourceVersion` is unset, set to "0", or set to a specific value.

### Method
WATCH (via HTTP GET with watch=true)

### Endpoint
Any Kubernetes resource collection endpoint (e.g., `/api/v1/pods`)

### Parameters
#### Query Parameters
- **resourceVersion** (string) - Optional - Determines the watch starting point. Unset: Get State and Start at Most Recent; "0": Get State and Start at Any; other value: Start at Exact.
- **watch** (boolean) - Required - Must be set to `true` to initiate a watch.

### Behavior by resourceVersion

#### resourceVersion unset
**Get State and Start at Most Recent**
- Starts at the most recent resource version, which must be consistent (served from etcd via a quorum read).
- Begins with synthetic "Added" events for all existing resource instances at the starting resource version.
- Subsequent events are for all changes after the starting resource version.

#### resourceVersion="0"
**Get State and Start at Any**
- Starts at any resource version; the most recent available is preferred but not required.
- May start at a much older resource version, potentially causing stale data.
- Begins with synthetic "Added" events for all existing resource instances at the starting resource version.
- Subsequent events are for all changes after the starting resource version.
- **Caution:** Watches initialized this way may return arbitrarily stale data.

#### resourceVersion="{value other than 0}"
**Start at Exact**
- Starts at the exact provided resource version.
- Watch events are for all changes after the provided resource version.
- No synthetic "Added" events are generated; the client is assumed to already have the initial state.

### Response
#### Success Response (200)
- Stream of watch events (Added, Modified, Deleted, etc.) with associated resource versions.

#### Error Responses
- **410 Gone**: Returned if the requested resourceVersion is older than the server has retained. Clients must tolerate this.
- **504 Gateway Timeout**: May be returned if the server waits briefly for an unrecognized resource version but it does not become available.
- **Retry-After header**: May be included in responses to indicate how many seconds to wait before retrying.

### Notes
- Servers are not required to serve all older resource versions.
- For unrecognized resource versions in watch requests, the API server may wait indefinitely until the request timeout.
- The kube-apiserver identifies unrecognized resource version errors with the message "Too large resource version".
```

--------------------------------

### kubectl create deployment examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/kubectl_create_deployment/

Examples of creating deployments with different options: basic image, command, replicas, port, and multiple containers.

```bash
  # Create a deployment named my-dep that runs the busybox image
  kubectl create deployment my-dep --image=busybox
  
  # Create a deployment with a command
  kubectl create deployment my-dep --image=busybox -- date
  
  # Create a deployment named my-dep that runs the nginx image with 3 replicas
  kubectl create deployment my-dep --image=nginx --replicas=3
  
  # Create a deployment named my-dep that runs the busybox image and expose port 5701
  kubectl create deployment my-dep --image=busybox --port=5701
  
  # Create a deployment named my-dep that runs multiple containers
  kubectl create deployment my-dep --image=busybox:latest --image=ubuntu:latest --image=nginx
```

--------------------------------

### View application logs with kubectl logs

Source: https://kubernetes.io/docs/tutorials/hello-minikube/

Fetches logs from a container in a pod. Replace the pod name with the one from kubectl get pods output. The example output shows the agnhost server starting on ports 8080 and 8081.

```shell
kubectl logs hello-node-5f76cf6ccf-br9b5
```

```text
I0911 09:19:26.677397       1 log.go:195] Started HTTP server on port 8080
I0911 09:19:26.677586       1 log.go:195] Started UDP server on port  8081
```

--------------------------------

### kubectl create ingress examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/kubectl_create_ingress/

Collection of examples showing how to create ingresses with various options like TLS, annotations, multiple paths, multiple hosts, and default backend.

```bash
  # Create a single ingress called 'simple' that directs requests to foo.com/bar to svc
  # svc1:8080 with a TLS secret "my-cert"
  kubectl create ingress simple --rule="foo.com/bar=svc1:8080,tls=my-cert"
  
  # Create a catch all ingress of "/path" pointing to service svc:port and Ingress Class as "otheringress"
  kubectl create ingress catch-all --class=otheringress --rule="/path=svc:port"
  
  # Create an ingress with two annotations: ingress.annotation1 and ingress.annotations2
  kubectl create ingress annotated --class=default --rule="foo.com/bar=svc:port" \
  --annotation ingress.annotation1=foo \
  --annotation ingress.annotation2=bla
  
  # Create an ingress with the same host and multiple paths
  kubectl create ingress multipath --class=default \
  --rule="foo.com/=svc:port" \
  --rule="foo.com/admin/=svcadmin:portadmin"
  
  # Create an ingress with multiple hosts and the pathType as Prefix
  kubectl create ingress ingress1 --class=default \
  --rule="foo.com/path*=svc:8080" \
  --rule="bar.com/admin*=svc2:http"
  
  # Create an ingress with TLS enabled using the default ingress certificate and different path types
  kubectl create ingress ingtls --class=default \
  --rule="foo.com/=svc:https,tls" \
  --rule="foo.com/path/subpath*=othersvc:8080"
  
  # Create an ingress with TLS enabled using a specific secret and pathType as Prefix
  kubectl create ingress ingsecret --class=default \
  --rule="foo.com/*=svc:8080,tls=secret1"
  
  # Create an ingress with a default backend
  kubectl create ingress ingdefault --class=default \
  --default-backend=defaultsvc:http \
  --rule="foo.com/*=svc:8080,tls=secret1"
```

--------------------------------

### kubeadm init phase kubelet-start example with config file

Source: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm-init-phase/

Writes a dynamic environment file with kubelet flags from an InitConfiguration file specified by --config.

```bash
  # Writes a dynamic environment file with kubelet flags from a InitConfiguration file.
  kubeadm init phase kubelet-start --config config.yaml
```

--------------------------------

### Install Jinja2 for Python

Source: https://kubernetes.io/docs/tasks/job/parallel-processing-expansion/

Install the Jinja2 template library for Python, required for the advanced templating example.

```shell
pip install --user jinja2
```

--------------------------------

### kubeadm init phase etcd local examples

Source: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm-init-phase/

Shows example commands for generating the etcd static Pod manifest, including using a configuration file.

```bash
  # Generates the static Pod manifest file for etcd, functionally
  # equivalent to what is generated by kubeadm init.
  kubeadm init phase etcd local
  
  # Generates the static Pod manifest file for etcd using options
  # read from a configuration file.
  kubeadm init phase etcd local --config config.yaml
```

--------------------------------

### Example output of kubectl get service audit-pod

Source: https://kubernetes.io/docs/tutorials/security/seccomp/

Shows the Service output with the NodePort (32373 in this example).

```text
NAME        TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
audit-pod   NodePort   10.111.36.142   <none>        5678:32373/TCP   72s
```

--------------------------------

### Example: prepare machine for serving a control plane

Source: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm-join-phase/

Shows how to run the control-plane-prepare all subcommand to prepare the machine for serving a control plane.

```bash
  # Prepares the machine for serving a control plane
  kubeadm join phase control-plane-prepare all
```

--------------------------------

### Start minikube with CNI network plugin

Source: https://kubernetes.io/docs/tasks/administer-cluster/network-policy-provider/cilium-network-policy/

Start minikube with the CNI network plugin to prepare for Cilium installation.

```shell
minikube start --network-plugin=cni
```

--------------------------------

### kubectl rollout restart examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_rollout/kubectl_rollout_restart/

Examples showing how to restart all deployments in a namespace, a specific deployment, a daemon set, and deployments matching a label selector.

```shell
  # Restart all deployments in the test-namespace namespace
  kubectl rollout restart deployment -n test-namespace
  
  # Restart a deployment
  kubectl rollout restart deployment/nginx
  
  # Restart a daemon set
  kubectl rollout restart daemonset/abc
  
  # Restart deployments with the app=nginx label
  kubectl rollout restart deployment --selector=app=nginx
```

--------------------------------

### kubectl completion examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_completion/

Examples for installing kubectl shell completion on macOS, Linux, and Windows for bash, zsh, fish, and powershell.

```shell
  # Installing bash completion on macOS using homebrew
  ## If running Bash 3.2 included with macOS
  brew install bash-completion
  ## or, if running Bash 4.1+
  brew install bash-completion@2
  ## If kubectl is installed via homebrew, this should start working immediately
  ## If you've installed via other means, you may need add the completion to your completion directory
  kubectl completion bash > $(brew --prefix)/etc/bash_completion.d/kubectl
  
  
  # Installing bash completion on Linux
  ## If bash-completion is not installed on Linux, install the 'bash-completion' package
  ## via your distribution's package manager.
  ## Load the kubectl completion code for bash into the current shell
  source <(kubectl completion bash)
  ## Write bash completion code to a file and source it from .bash_profile
  kubectl completion bash > ~/.kube/completion.bash.inc
  printf "
  # kubectl shell completion
  source '$HOME/.kube/completion.bash.inc'
  " >> $HOME/.bash_profile
  source $HOME/.bash_profile
  
  # Load the kubectl completion code for zsh[1] into the current shell
  source <(kubectl completion zsh)
  # Set the kubectl completion code for zsh[1] to autoload on startup
  kubectl completion zsh > "${fpath[1]}/_kubectl"
  
  
  # Load the kubectl completion code for fish[2] into the current shell
  kubectl completion fish | source
  # To load completions for each session, execute once:
  kubectl completion fish > ~/.config/fish/completions/kubectl.fish
  
  # Load the kubectl completion code for powershell into the current shell
  kubectl completion powershell | Out-String | Invoke-Expression
  # Set kubectl completion code for powershell to run on startup
  ## Save completion code to a script and execute in the profile
  kubectl completion powershell > "$HOME\.kube\completion.ps1"
  Add-Content $PROFILE ". '$HOME\.kube\completion.ps1'"
  ## Execute completion code in the profile
  Add-Content $PROFILE "if (Get-Command kubectl -ErrorAction SilentlyContinue) {
  kubectl completion powershell | Out-String | Invoke-Expression
  }"
  ## Add completion code directly to the $PROFILE script
  kubectl completion powershell >> $PROFILE
```

--------------------------------

### kubeadm init phase addon all

Source: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm-init-phase/

Install all the addons. This includes CoreDNS and kube-proxy.

```bash
kubeadm init phase addon all [flags]
```

--------------------------------

### Create the Job from the manifest URL

Source: https://kubernetes.io/docs/tasks/job/pod-failure-policy/

Applies the Job manifest hosted at the Kubernetes examples URL. Use this to start the example workflow.

```sh
kubectl create -f https://k8s.io/examples/controllers/job-pod-failure-policy-ignore.yaml
```

--------------------------------

### Create a Deployment with five replicas using load-balancer-example.yaml

Source: https://kubernetes.io/docs/tutorials/stateless-application/expose-external-ip-address/

Defines a Deployment named hello-world with 5 replicas running the hello-app:2.0 image on port 8080. Apply this YAML to create the Deployment and its ReplicaSet.

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app.kubernetes.io/name: load-balancer-example
  name: hello-world
spec:
  replicas: 5
  selector:
    matchLabels:
      app.kubernetes.io/name: load-balancer-example
  template:
    metadata:
      labels:
        app.kubernetes.io/name: load-balancer-example
    spec:
      containers:
      - image: gcr.io/google-samples/hello-app:2.0
        name: hello-world
        ports:
        - containerPort: 8080
```

--------------------------------

### Example output of kubectl get namespaces

Source: https://kubernetes.io/docs/tutorials/cluster-management/namespaces-walkthrough/

This is the expected output after running kubectl get namespaces on a fresh cluster, showing the default namespace.

```text
NAME      STATUS    AGE
default   Active    13m
```

--------------------------------

### Output of kubectl get po

Source: https://kubernetes.io/docs/reference/kubectl/docker-cli-to-kubectl/

Example output of kubectl get po showing pod name, readiness, status, restarts, and age.

```text
NAME              READY     STATUS    RESTARTS   AGE
nginx-app-5jyvm   1/1       Running   0          10m
```

--------------------------------

### Create the Hello World Deployment

Source: https://kubernetes.io/docs/tasks/access-application-cluster/service-access-application-cluster/

Applies the Deployment manifest from the URL, creating a Deployment and a ReplicaSet with two Pods.

```shell
kubectl apply -f https://k8s.io/examples/service/access/hello-application.yaml
```

--------------------------------

### Apply the DRA example Job with kubectl

Source: https://kubernetes.io/docs/tasks/configure-pod-container/assign-resources/allocate-devices-dra/

Creates the example Job from the hosted manifest. Use this after reviewing the Job definition to start the workload.

```shell
kubectl apply -f https://k8s.io/examples/dra/dra-example-job.yaml
```

--------------------------------

### Example Pod List Output

Source: https://kubernetes.io/docs/tasks/access-application-cluster/service-access-application-cluster/

Sample output from kubectl get pods showing two running Hello World Pods with their IPs and nodes.

```none
NAME                           READY   STATUS    ...  IP           NODE
hello-world-2895499144-bsbk5   1/1     Running   ...  10.200.1.4   worker1
hello-world-2895499144-m1pwt   1/1     Running   ...  10.200.2.5   worker2
```

--------------------------------

### Create a namespace for QoS example

Source: https://kubernetes.io/docs/tasks/configure-pod-container/quality-service-pod/

Creates a namespace named qos-example to isolate resources for this exercise.

```shell
kubectl create namespace qos-example
```

--------------------------------

### Add a startupProbe to protect a slow-starting container

Source: https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/

Extends the named-port liveness probe example with a startupProbe using the same HTTP check. With failureThreshold 30 and periodSeconds 10, the app gets up to 300s to start; once the startup probe succeeds, the liveness probe takes over, and if it never succeeds the container is killed after 300s and subject to the pod's restartPolicy.

```yaml
ports:
- name: liveness-port
  containerPort: 8080

livenessProbe:
  httpGet:
    path: /healthz
    port: liveness-port
  failureThreshold: 1
  periodSeconds: 10

startupProbe:
  httpGet:
    path: /healthz
    port: liveness-port
  failureThreshold: 30
  periodSeconds: 10
```

--------------------------------

### kubectl create token examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/kubectl_create_token/

Examples showing how to request tokens with various options such as namespace, duration, audience, and object binding.

```bash
  # Request a token to authenticate to the kube-apiserver as the service account "myapp" in the current namespace
  kubectl create token myapp
  
  # Request a token for a service account in a custom namespace
  kubectl create token myapp --namespace myns
  
  # Request a token with a custom expiration
  kubectl create token myapp --duration 10m
  
  # Request a token with a custom audience
  kubectl create token myapp --audience https://example.com
  
  # Request a token bound to an instance of a Secret object
  kubectl create token myapp --bound-object-kind Secret --bound-object-name mysecret
  
  # Request a token bound to an instance of a Secret object with a specific UID
  kubectl create token myapp --bound-object-kind Secret --bound-object-name mysecret --bound-object-uid 0d4691ed-659b-4935-a832-355f77ee47cc
```

--------------------------------

### Install procps and List Processes

Source: https://kubernetes.io/docs/tasks/configure-pod-container/configure-volume-storage/

Updates package lists, installs procps to get ps, and lists running processes to find the Redis PID.

```shell
root@redis:/data/redis# apt-get update
root@redis:/data/redis# apt-get install procps
root@redis:/data/redis# ps aux
```

--------------------------------

### kubectl List Output Example

Source: https://kubernetes.io/docs/reference/using-api/api-concepts/

Example output from kubectl get services -A -o yaml, showing a List with items of kind Service.

```yaml
apiVersion: v1
kind: List
metadata:
  resourceVersion: ""
  selfLink: ""
items:
- apiVersion: v1
  kind: Service
  metadata:
    creationTimestamp: "2021-06-03T14:54:12Z"
    labels:
      component: apiserver
      provider: kubernetes
    name: kubernetes
    namespace: default
...
- apiVersion: v1
  kind: Service
  metadata:
    annotations:
      prometheus.io/port: "9153"
      prometheus.io/scrape: "true"
    creationTimestamp: "2021-06-03T14:54:14Z"
    labels:
      k8s-app: kube-dns
      kubernetes.io/cluster-service: "true"
      kubernetes.io/name: CoreDNS
    name: kube-dns
    namespace: kube-system

```

--------------------------------

### kubectl create configmap examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_create/kubectl_create_configmap/

Examples for creating config maps from a directory, files with custom keys, literal key-value pairs, and an env file.

```bash
  # Create a new config map named my-config based on folder bar
  kubectl create configmap my-config --from-file=path/to/bar
  
  # Create a new config map named my-config with specified keys instead of file basenames on disk
  kubectl create configmap my-config --from-file=key1=/path/to/bar/file1.txt --from-file=key2=/path/to/bar/file2.txt
  
  # Create a new config map named my-config with key1=config1 and key2=config2
  kubectl create configmap my-config --from-literal=key1=config1 --from-literal=key2=config2
  
  # Create a new config map named my-config with key=value pairs from an env file
  kubectl create configmap my-config --from-env-file=path/to/bar.env
```

--------------------------------

### kubectl auth whoami examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_auth/kubectl_auth_whoami/

Provides examples of using kubectl auth whoami to get subject attributes, including output in JSON format.

```bash
  # Get your subject attributes
  kubectl auth whoami
  
  # Get your subject attributes in JSON format
  kubectl auth whoami -o json
```

--------------------------------

### Example output of kubectl get endpointslice for kube-dns

Source: https://kubernetes.io/docs/tasks/administer-cluster/dns-debugging-resolution/

This is an example output showing the endpoints for the kube-dns service. If no endpoints are shown, refer to the debugging Services documentation.

```text
NAME             ADDRESSTYPE   PORTS   ENDPOINTS                  AGE
coredns-zxoja    IPv4          53      10.180.3.17,10.180.3.17    1h
```

--------------------------------

### Download sample files and create ConfigMap from directory

Source: https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/

Downloads game.properties and ui.properties into the directory, then creates a ConfigMap named game-config from all files in that directory.

```shell
# Download the sample files into `configure-pod-container/configmap/` directory
wget https://kubernetes.io/examples/configmap/game.properties -O configure-pod-container/configmap/game.properties
wget https://kubernetes.io/examples/configmap/ui.properties -O configure-pod-container/configmap/ui.properties

# Create the ConfigMap
kubectl create configmap game-config --from-file=configure-pod-container/configmap/
```

--------------------------------

### Sample Pod list output

Source: https://kubernetes.io/docs/tutorials/configuration/updating-configuration-via-a-configmap/

Example output showing three Pods with 2/2 containers ready and status Running.

```text
NAME                                           READY   STATUS    RESTARTS   AGE
configmap-sidecar-container-5fb59f558b-87rp7   2/2     Running   0          94s
configmap-sidecar-container-5fb59f558b-ccs7s   2/2     Running   0          94s
configmap-sidecar-container-5fb59f558b-wnmgk   2/2     Running   0          94s
```

--------------------------------

### Example output of kubectl get svc for kube-dns

Source: https://kubernetes.io/docs/tasks/administer-cluster/dns-debugging-resolution/

This is an example output showing the kube-dns service. The service is named kube-dns for backward compatibility with the original kube-dns.

```text
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)             AGE
...
kube-dns     ClusterIP   10.0.0.10      <none>        53/UDP,53/TCP        1h
...
```

--------------------------------

### Install kubelet binary

Source: https://kubernetes.io/docs/tutorials/cluster-management/kubelet-standalone/

Make the downloaded kubelet binary executable and copy it to /usr/bin/.

```shell
chmod +x kubelet
sudo cp kubelet /usr/bin/
```

--------------------------------

### Example kube-controller-manager cluster signing flags with default paths

Source: https://kubernetes.io/docs/reference/access-authn-authz/kubelet-tls-bootstrapping/

Example using common default paths for the CA certificate and key. Adjust according to your setup.

```shell
--cluster-signing-cert-file="/var/lib/kubernetes/ca.pem" --cluster-signing-key-file="/var/lib/kubernetes/ca-key.pem"
```

--------------------------------

### Get DaemonSet with curl via kubectl proxy

Source: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.35/

Requires kubectl proxy to be running. Starts the proxy and then sends a GET request to the Kubernetes API to retrieve the specified DaemonSet.

```bash
$ kubectl proxy
$ curl -X GET http://127.0.0.1:8001/apis/apps/v1/namespaces/default/daemonsets/daemonset-example
```

--------------------------------

### Create the Pod using kubectl apply

Source: https://kubernetes.io/docs/tasks/inject-data-application/define-environment-variable-via-file/

Deploys the Pod manifest from the Kubernetes examples URL.

```shell
kubectl apply -f https://k8s.io/examples/pods/inject/envars-file-container.yaml
```

--------------------------------

### Send GET request to nginx server

Source: https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-initialization/

Inside the nginx container, installs curl and sends a GET request to localhost to verify nginx serves the page written by the init container.

```shell
root@nginx:~# apt-get update
root@nginx:~# apt-get install curl
root@nginx:~# curl localhost
```

--------------------------------

### kubectl kustomize usage examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_kustomize/

Demonstrates building the current working directory, a shared configuration directory, and a remote GitHub repository. The GitHub example includes a ref query parameter to specify a version.

```shell
  # Build the current working directory
  kubectl kustomize
  
  # Build some shared configuration directory
  kubectl kustomize /home/config/production
  
  # Build from github
  kubectl kustomize https://github.com/kubernetes-sigs/kustomize.git/examples/helloWorld?ref=v1.0.6
```

--------------------------------

### kubectl expose examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_expose/

Examples of exposing different resources (replication controller, pod, service, replica set, deployment) with various port, protocol, and naming options.

```bash
  # Create a service for a replicated nginx, which serves on port 80 and connects to the containers on port 8000
  kubectl expose rc nginx --port=80 --target-port=8000
  
  # Create a service for a replication controller identified by type and name specified in "nginx-controller.yaml", which serves on port 80 and connects to the containers on port 8000
  kubectl expose -f nginx-controller.yaml --port=80 --target-port=8000
  
  # Create a service for a pod valid-pod, which serves on port 444 with the name "frontend"
  kubectl expose pod valid-pod --port=444 --name=frontend
  
  # Create a second service based on the above service, exposing the container port 8443 as port 443 with the name "nginx-https"
  kubectl expose service nginx --port=443 --target-port=8443 --name=nginx-https
  
  # Create a service for a replicated streaming application on port 4100 balancing UDP traffic and named 'video-stream'.
  kubectl expose rc streamer --port=4100 --protocol=UDP --name=video-stream
  
  # Create a service for a replicated nginx using replica set, which serves on port 80 and connects to the containers on port 8000
  kubectl expose rs nginx --port=80 --target-port=8000
  
  # Create a service for an nginx deployment, which serves on port 80 and connects to the containers on port 8000
  kubectl expose deployment nginx --port=80 --target-port=8000
```

--------------------------------

### kubectl set resources examples

Source: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_set/kubectl_set_resources/

Examples for setting CPU and memory limits, setting requests and limits, removing requests and limits, and previewing changes locally in YAML format.

```shell
  # Set a deployments nginx container cpu limits to "200m" and memory to "512Mi"
  kubectl set resources deployment nginx -c=nginx --limits=cpu=200m,memory=512Mi
  
  # Set the resource request and limits for all containers in nginx
  kubectl set resources deployment nginx --limits=cpu=200m,memory=512Mi --requests=cpu=100m,memory=256Mi
  
  # Remove the resource requests for resources on containers in nginx
  kubectl set resources deployment nginx --limits=cpu=0,memory=0 --requests=cpu=0,memory=0
  
  # Print the result (in yaml format) of updating nginx container limits from a local, without hitting the server
  kubectl set resources -f path/to/file.yaml --limits=cpu=200m,memory=512Mi --local -o yaml
```

--------------------------------

### Get Deployment via curl through kubectl proxy

Source: https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.37/

Requires kubectl proxy to be running. Starts the proxy and issues a GET request to the apps/v1 deployments endpoint for deployment-example in the default namespace.

```shell
codeList
```

--------------------------------

### Example output of kubectl get pvc after deletion

Source: https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/

Shows that no resources were found in the default namespace.

```text
No resources found in default namespace.
```

--------------------------------

### Create and install kubectl-foo-bar-baz plugin

Source: https://kubernetes.io/docs/tasks/extend-kubectl/kubectl-plugins/

Create a plugin that echoes its first argument, make it executable, move it to /usr/local/bin, and list plugins to verify kubectl recognizes it.

```bash
# create a plugin
echo -e '#!/bin/bash\n\necho "My first command-line argument was $1"' > kubectl-foo-bar-baz
sudo chmod +x ./kubectl-foo-bar-baz

# "install" your plugin by moving it to a directory in your $PATH
sudo mv ./kubectl-foo-bar-baz /usr/local/bin

# check that kubectl recognizes your plugin
kubectl plugin list
```

```text
The following kubectl-compatible plugins are available:

/usr/local/bin/kubectl-foo-bar-baz
```

--------------------------------

### kubeadm init phase kubelet-start synopsis

Source: https://kubernetes.io/docs/reference/setup-tools/kubeadm/kubeadm-init-phase/

Displays the command usage for the kubelet-start phase.

```bash
kubeadm init phase kubelet-start [flags]
```

--------------------------------

### Example output of kubectl get pvc

Source: https://kubernetes.io/docs/tutorials/stateful-application/basic-stateful-set/

Shows the PersistentVolumeClaims with names www-web-0 through www-web-4, all Bound.

```text
NAME        STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
www-web-0   Bound    pvc-2bf00408-d366-4a12-bad0-1869c65d0bee   1Gi        RWO            standard       25m
www-web-1   Bound    pvc-ba3bfe9c-413e-4b95-a2c0-3ea8a54dbab4   1Gi        RWO            standard       24m
www-web-2   Bound    pvc-cba6cfa6-3a47-486b-a138-db5930207eaf   1Gi        RWO            standard       15m
www-web-3   Bound    pvc-0c04d7f0-787a-4977-8da3-d9d3a6d8d752   1Gi        RWO            standard       15m
www-web-4   Bound    pvc-b2c73489-e70b-4a4e-9ec1-9eab439aa43e   1Gi        RWO            standard       14m
```

--------------------------------

### Apply the load-balancer-example.yaml Deployment

Source: https://kubernetes.io/docs/tutorials/stateless-application/expose-external-ip-address/

Creates the Deployment and ReplicaSet from the remote YAML file. The ReplicaSet will have five Pods running the Hello World application.

```shell
kubectl apply -f https://k8s.io/examples/service/load-balancer-example.yaml
```

--------------------------------

### Output of kubectl get svc

Source: https://kubernetes.io/docs/tasks/network/validate-dual-stack/

Example output showing the Service with only the primary cluster IP.

```text
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
my-service   ClusterIP   10.0.216.242   <none>        80/TCP    5s
```

--------------------------------

### Expose Deployment as NodePort Service

Source: https://kubernetes.io/docs/tasks/access-application-cluster/service-access-application-cluster/

Creates a Service named example-service of type NodePort that targets the hello-world Deployment.

```shell
kubectl expose deployment hello-world --type=NodePort --name=example-service
```

--------------------------------

### Output of getting CronJob status after scheduling

Source: https://kubernetes.io/docs/tasks/job/automated-tasks-with-cron-jobs/

Example output showing the CronJob has scheduled a job.

```text
NAME    SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
hello   */1 * * * *   False     0        50s             75s
```

--------------------------------

### Download kind configuration example

Source: https://kubernetes.io/docs/tutorials/security/seccomp/

Downloads the example kind configuration file from the Kubernetes website and saves it as kind.yaml. Run this before creating the cluster.

```shell
curl -L -O https://k8s.io/examples/pods/security/seccomp/kind.yaml
```

--------------------------------

### Output of getting CronJob status

Source: https://kubernetes.io/docs/tasks/job/automated-tasks-with-cron-jobs/

Example output showing the CronJob has not scheduled any jobs yet.

```text
NAME    SCHEDULE      SUSPEND   ACTIVE   LAST SCHEDULE   AGE
hello   */1 * * * *   False     0        <none>          10s
```

--------------------------------

### Example output of ResourceSlices

Source: https://kubernetes.io/docs/tasks/configure-pod-container/assign-resources/set-up-dra-cluster/

This shows the format of the output from 'kubectl get resourceslices' when drivers are functioning.

```text
NAME                                                  NODE                DRIVER               POOL                             AGE
00000-driver.example.com-cluster-1-node-1-abcde      cluster-1-node-1    driver.example.com   cluster-1-device-pool-1-r1gc     7s
00000-driver.example.com-cluster-1-node-2-fghij      cluster-1-node-2    driver.example.com   cluster-1-device-pool-2-446z     8s
```

--------------------------------

### Example generated Configuration API files

Source: https://kubernetes.io/docs/contribute/generate-ref-docs/config-api/

Example updates under content/en/docs/reference/config-api after running make copyconfigapi.

```text
content/en/docs/reference/config-api/kubelet-config.v1beta1.md
content/en/docs/reference/config-api/kubeadm-config.v1beta4.md
content/en/docs/reference/config-api/apiserver-config.v1.md
content/en/docs/reference/config-api/client-authentication.v1.md
```

--------------------------------

### Default kubeadm kubelet systemd drop-in file

Source: https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/kubelet-integration/

Example contents of /usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf installed by the kubeadm package. It defines environment variables for kubelet arguments and the ExecStart command. Override settings by creating files in /etc/systemd/system/kubelet.service.d/.

```none
[Service]
Environment="KUBELET_KUBECONFIG_ARGS=--bootstrap-kubeconfig=/etc/kubernetes/bootstrap-kubelet.conf --kubeconfig=/etc/kubernetes/kubelet.conf"
Environment="KUBELET_CONFIG_ARGS=--config=/var/lib/kubelet/config.yaml"
# This is a file that "kubeadm init" and "kubeadm join" generate at runtime, populating
# the KUBELET_KUBEADM_ARGS variable dynamically
EnvironmentFile=-/var/lib/kubelet/kubeadm-flags.env
# This is a file that the user can use for overrides of the kubelet args as a last resort. Preferably,
# the user should use the .NodeRegistration.KubeletExtraArgs object in the configuration files instead.
# KUBELET_EXTRA_ARGS should be sourced from this file.
EnvironmentFile=-/etc/default/kubelet
ExecStart=
ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_CONFIG_ARGS $KUBELET_KUBEADM_ARGS $KUBELET_EXTRA_ARGS
```

--------------------------------

### Get a shell to the running container

Source: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/

Starts an interactive shell session inside the security-context-demo container.

```shell
kubectl exec -it security-context-demo -- sh
```
Tokens:
Raw