## If you know the node IP address
ssh user@<node-ip>

## Using kubectl to get node IPs first
kubectl get nodes -o wide

## Alternative: use kubectl debug to get a shell on a node
## (requires Kubernetes 1.18+ with ephemeral containers enabled)
kubectl debug node/<node-name> -it --image=ubuntu

## Check if crictl is available on the node
which crictl

## If installed, check the version
crictl --version

## Expected output (example):
## crictl version v1.29.0

## Check which container runtime the kubelet is using
ps aux | grep kubelet | grep -- --container-runtime-endpoint

## Alternative: check the kubelet configuration
sudo cat /var/lib/kubelet/config.yaml | grep -i container

## For containerd, check if the socket exists
ls -la /run/containerd/containerd.sock

## For CRI-O, check if the socket exists
ls -la /var/run/crio/crio.sock

## Instead of a config file, you can specify the endpoint per command
crictl --runtime-endpoint unix:///run/containerd/containerd.sock ps

## Or set it as an environment variable
export CONTAINER_RUNTIME_ENDPOINT=unix:///run/containerd/containerd.sock

## Now all crictl commands will use this endpoint
crictl ps

## Temporarily enable debug mode for troubleshooting
## This shows the gRPC calls being made to the runtime
sudo tee /etc/crictl.yaml <<EOF
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: true
EOF

## Run a command with debug output
crictl ps

## Remember to disable debug mode when done
## (set debug: false in /etc/crictl.yaml)

## Verify crictl can communicate with the runtime
crictl info

## Expected output: JSON with runtime information including
## version, storage driver, and runtime conditions

## Quick sanity check: list running containers
crictl ps

## List all pods managed by the runtime
crictl pods

## List all pod sandboxes (running and stopped)
crictl pods

## Example output:
## POD ID         CREATED        STATE   NAME                          NAMESPACE     ATTEMPT  RUNTIME
## a1b2c3d4e5f6   2 hours ago    Ready   nginx-7d456b8f9c-abcde       default       0        (default)
## f6e5d4c3b2a1   3 hours ago    Ready   coredns-5dd5756b68-xyz12     kube-system   0        (default)

## Filter pods by name
crictl pods --name nginx

## Filter pods by namespace
crictl pods --namespace kube-system

## Filter pods by state (Ready or NotReady)
crictl pods --state Ready

## Filter pods that are not ready (stopped, failed, etc.)
crictl pods --state NotReady

## Filter pods by label
crictl pods --label app=nginx

## Filter by multiple labels
crictl pods --label app=nginx --label version=v1

## Combine multiple filters
crictl pods --namespace default --state Ready --label app=nginx

## Show full pod IDs (not truncated)
crictl pods --no-trunc

## Show only pod IDs (useful for scripting)
crictl pods --quiet

## Show pods with additional information in verbose mode
crictl pods --verbose

## Output in JSON format for programmatic consumption
crictl pods -o json

## Output in YAML format
crictl pods -o yaml

## Output in table format (default)
crictl pods -o table

## Show only the last 5 pods created
crictl pods --last 5

## Show the most recently created pod
crictl pods --last 1

## First, get the pod ID you want to inspect
crictl pods
## Note the POD ID from the output (e.g., a1b2c3d4e5f6)

## Inspect the pod sandbox by its ID
crictl inspectp a1b2c3d4e5f6

## You can also use a partial ID (as long as it is unique)
crictl inspectp a1b2c3

## Inspect a pod and pipe through jq for readability
crictl inspectp a1b2c3d4e5f6 | jq .

## Get the pod's network information
## This shows the pod IP address and network namespace
crictl inspectp a1b2c3d4e5f6 | jq '.status.network'

## Example output:
## {
##   "additionalIps": [],
##   "ip": "10.244.0.15"
## }

## Get the pod's Linux namespace paths
crictl inspectp a1b2c3d4e5f6 | jq '.info.runtimeSpec.linux.namespaces'

## Get the pod's labels
crictl inspectp a1b2c3d4e5f6 | jq '.status.labels'

## Get the pod's annotations
crictl inspectp a1b2c3d4e5f6 | jq '.status.annotations'

## Get the pod's DNS configuration
crictl inspectp a1b2c3d4e5f6 | jq '.info.runtimeSpec.linux.resources'

## Get the creation timestamp
crictl inspectp a1b2c3d4e5f6 | jq '.status.createdAt'

## Get the pod's state
crictl inspectp a1b2c3d4e5f6 | jq '.status.state'

## Get the network namespace path for a pod
## This is useful for debugging networking issues with nsenter
NETNS=$(crictl inspectp a1b2c3d4e5f6 | jq -r '.info.runtimeSpec.linux.namespaces[] | select(.type=="network") | .path')
echo "Network namespace: $NETNS"

## Enter the pod's network namespace to debug networking
## (requires nsenter installed on the node)
sudo nsenter --net=$NETNS ip addr show

## Check the routes inside the pod's network namespace
sudo nsenter --net=$NETNS ip route show

## Check DNS resolution from inside the network namespace
sudo nsenter --net=$NETNS cat /etc/resolv.conf

## List all running containers
crictl ps

## Example output:
## CONTAINER      IMAGE          CREATED        STATE    NAME       ATTEMPT  POD ID         POD
## b1c2d3e4f5g6   nginx:1.25     2 hours ago    Running  nginx      0        a1b2c3d4e5f6   nginx-7d456b8f9c-abcde
## h7i8j9k0l1m2   coredns:1.11   3 hours ago    Running  coredns    0        f6e5d4c3b2a1   coredns-5dd5756b68-xyz12

## List ALL containers (including exited, created, unknown states)
crictl ps -a

## Example output showing exited containers:
## CONTAINER      IMAGE          CREATED        STATE    NAME       ATTEMPT  POD ID         POD
## b1c2d3e4f5g6   nginx:1.25     2 hours ago    Running  nginx      0        a1b2c3d4e5f6   nginx-...
## n3o4p5q6r7s8   busybox:1.36   1 hour ago     Exited   init-db    0        t9u0v1w2x3y4   myapp-...

## Filter containers by name
crictl ps --name nginx

## Filter containers by state
crictl ps --state Running
crictl ps --state Exited
crictl ps --state Created
crictl ps --state Unknown

## Filter containers by image
crictl ps --image nginx

## Filter containers by label
crictl ps --label io.kubernetes.container.name=nginx

## Filter containers belonging to a specific pod
crictl ps --pod a1b2c3d4e5f6

## Combine filters: show exited containers for a specific pod
crictl ps -a --state Exited --pod a1b2c3d4e5f6

## Show only the last N containers
crictl ps -a --last 10

## Show full IDs (not truncated)
crictl ps --no-trunc

## Show only container IDs (useful for scripting)
crictl ps --quiet

## JSON output for programmatic processing
crictl ps -o json

## YAML output
crictl ps -o yaml

## Show all containers with verbose output
crictl ps -a --verbose

## Count running containers
crictl ps --quiet | wc -l

## Count all containers (including stopped)
crictl ps -a --quiet | wc -l

## Count exited containers only
crictl ps -a --state Exited --quiet | wc -l

## List all containers with their exit codes (exited containers)
crictl ps -a --state Exited -o json | jq '.containers[] | {name: .metadata.name, id: .id, exitCode: .state}'

## First, get the container ID
crictl ps
## Note the CONTAINER ID (e.g., b1c2d3e4f5g6)

## Inspect the container
crictl inspect b1c2d3e4f5g6

## Inspect with pretty-printed JSON (pipe through jq)
crictl inspect b1c2d3e4f5g6 | jq .

## Get the container's image reference
crictl inspect b1c2d3e4f5g6 | jq '.status.image.image'

## Get the container's PID (process ID on the host)
crictl inspect b1c2d3e4f5g6 | jq '.info.pid'

## Get the container's resource limits (CPU and memory)
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.linux.resources'

## Get CPU limits specifically
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.linux.resources.cpu'

## Get memory limits specifically
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.linux.resources.memory'

## Get the container's environment variables
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.process.env'

## Get the container's mount points
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.mounts'

## Get the container's startup command and arguments
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.process.args'

## Get the container's working directory
crictl inspect b1c2d3e4f5g6 | jq '.info.runtimeSpec.process.cwd'

## Get the container's state and exit code (for exited containers)
crictl inspect b1c2d3e4f5g6 | jq '{state: .status.state, exitCode: .status.exitCode, reason: .status.reason}'

## Get the container's creation and start timestamps
crictl inspect b1c2d3e4f5g6 | jq '{created: .status.createdAt, started: .status.startedAt, finished: .status.finishedAt}'

## Get the container's log path
crictl inspect b1c2d3e4f5g6 | jq '.status.logPath'

## When debugging a CrashLoopBackOff, inspect the exited container
## to find the exit code and reason

## List exited containers
crictl ps -a --state Exited

## Inspect the exited container
crictl inspect n3o4p5q6r7s8 | jq '{
  name: .status.metadata.name,
  state: .status.state,
  exitCode: .status.exitCode,
  reason: .status.reason,
  message: .status.message,
  startedAt: .status.startedAt,
  finishedAt: .status.finishedAt
}'

## Common exit codes:
## 0   = Success (normal termination)
## 1   = General error
## 126 = Command not executable
## 127 = Command not found
## 137 = Killed by SIGKILL (OOMKilled or manual kill)
## 139 = Segmentation fault (SIGSEGV)
## 143 = Killed by SIGTERM (graceful shutdown)

## View logs for a running container
crictl logs b1c2d3e4f5g6

## View logs for an exited container (useful for crash debugging)
## First find the exited container ID
crictl ps -a --state Exited
## Then view its logs
crictl logs n3o4p5q6r7s8

## Follow logs in real-time (like tail -f)
crictl logs --follow b1c2d3e4f5g6

## Show only the last N lines
crictl logs --tail 50 b1c2d3e4f5g6

## Show only the last 10 lines
crictl logs --tail 10 b1c2d3e4f5g6

## Show logs with timestamps
crictl logs --timestamps b1c2d3e4f5g6

## Example output with timestamps:
## 2024-01-15T10:30:45.123456789Z 172.17.0.1 - - [15/Jan/2024:10:30:45 +0000] "GET / HTTP/1.1" 200 615

## Show logs since a specific time (RFC3339 format)
crictl logs --since "2024-01-15T10:00:00Z" b1c2d3e4f5g6

## Show logs from the last 5 minutes
## (Calculate the timestamp 5 minutes ago)
crictl logs --since "$(date -u -d '5 minutes ago' +%Y-%m-%dT%H:%M:%SZ)" b1c2d3e4f5g6

## Show logs until a specific time
crictl logs --until "2024-01-15T11:00:00Z" b1c2d3e4f5g6

## Combine: follow logs with timestamps, showing only the last 20 lines
crictl logs --follow --timestamps --tail 20 b1c2d3e4f5g6

## When a container restarts (CrashLoopBackOff), you may want to see
## logs from the previous instance

## List all containers (including exited) for a specific pod
crictl ps -a --pod a1b2c3d4e5f6

## The output shows ATTEMPT numbers:
## CONTAINER      IMAGE     CREATED        STATE    NAME     ATTEMPT  POD ID
## b1c2d3e4f5g6   nginx     1 min ago      Running  nginx    3        a1b2...
## x1y2z3a4b5c6   nginx     3 min ago      Exited   nginx    2        a1b2...
## d6e7f8g9h0i1   nginx     5 min ago      Exited   nginx    1        a1b2...

## View logs from the previous (exited) container instance
crictl logs x1y2z3a4b5c6

## View logs from the oldest instance
crictl logs d6e7f8g9h0i1

## Execute a single command in a container
crictl exec b1c2d3e4f5g6 ls /

## Execute a command with arguments
crictl exec b1c2d3e4f5g6 cat /etc/hostname

## Check the container's IP address
crictl exec b1c2d3e4f5g6 ip addr show

## View running processes inside the container
crictl exec b1c2d3e4f5g6 ps aux

## Check DNS resolution inside the container
crictl exec b1c2d3e4f5g6 cat /etc/resolv.conf

## Test network connectivity from inside the container
crictl exec b1c2d3e4f5g6 wget -qO- http://kubernetes.default.svc.cluster.local/healthz

## Open an interactive shell inside the container
## -i = interactive (keep stdin open)
## -t = allocate a pseudo-TTY
crictl exec -it b1c2d3e4f5g6 /bin/sh

## If the container has bash available
crictl exec -it b1c2d3e4f5g6 /bin/bash

## Once inside the container, you can run commands interactively:
## # ls /app
## # env
## # curl localhost:8080/health
## # exit

## Check if a specific port is listening inside the container
crictl exec b1c2d3e4f5g6 netstat -tlnp

## Check environment variables (useful for debugging misconfiguration)
crictl exec b1c2d3e4f5g6 env

## Check file system mounts inside the container
crictl exec b1c2d3e4f5g6 mount

## Read application configuration files
crictl exec b1c2d3e4f5g6 cat /etc/nginx/nginx.conf

## Check available disk space inside the container
crictl exec b1c2d3e4f5g6 df -h

## Test if another service is reachable from this container
crictl exec b1c2d3e4f5g6 ping -c 3 google.com

## List all images on the node
crictl images

## Example output:
## IMAGE                                     TAG        IMAGE ID       SIZE
## docker.io/library/nginx                   1.25       a6bd71f48f68   67.3MB
## registry.k8s.io/coredns/coredns           v1.11.1    cbb01a7bd410   16.2MB
## registry.k8s.io/etcd                      3.5.10     a0d6d4a97e3c   102MB
## registry.k8s.io/kube-apiserver            v1.29.0    e7972205b661   128MB
## registry.k8s.io/kube-proxy                v1.29.0    2d4e6e23bb50   82.5MB
## registry.k8s.io/pause                     3.9        e6f181688397   744kB

## Show full image IDs (not truncated)
crictl images --no-trunc

## Show only image IDs (useful for scripting)
crictl images --quiet

## Show images with digests
crictl images --digests

## Output in JSON format
crictl images -o json

## Output in YAML format
crictl images -o yaml

## Filter images by repository name
crictl images nginx

## Filter images by full reference
crictl images docker.io/library/nginx:1.25

## Pull an image from a registry
crictl pull nginx:latest

## Pull a specific version
crictl pull nginx:1.25.3

## Pull from a specific registry
crictl pull docker.io/library/alpine:3.19

## Pull from a private registry (requires authentication configured in containerd)
crictl pull myregistry.example.com/myapp:v1.0

## Pull and show progress
crictl pull --no-trunc busybox:latest

## Inspect a specific image to see its details
crictl inspecti nginx:latest

## Pretty-print the image inspection
crictl inspecti nginx:latest | jq .

## Get the image size
crictl inspecti nginx:latest | jq '.info.size'

## Get the image's environment variables
crictl inspecti nginx:latest | jq '.info.imageSpec.config.Env'

## Get the image's entrypoint and command
crictl inspecti nginx:latest | jq '{entrypoint: .info.imageSpec.config.Entrypoint, cmd: .info.imageSpec.config.Cmd}'

## Get the image's exposed ports
crictl inspecti nginx:latest | jq '.info.imageSpec.config.ExposedPorts'

## Get the image's labels
crictl inspecti nginx:latest | jq '.info.imageSpec.config.Labels'

## Remove a specific image by tag
crictl rmi nginx:latest

## Remove a specific image by image ID
crictl rmi a6bd71f48f68

## Remove multiple images at once
crictl rmi nginx:latest alpine:3.19 busybox:latest

## Remove all unused images (images not referenced by any container)
crictl rmi --prune

## Force remove all images (use with caution!)
## This will remove images even if containers are using them
crictl rmi --all

## Show image filesystem usage on the node
crictl imagefsinfo

## Pretty-print the output
crictl imagefsinfo | jq .

## This shows:
## - Timestamp of the information
## - Filesystem identifier (device, mountpoint)
## - Used bytes and inodes
## - Total bytes and inodes available

## Show resource usage for all running containers
crictl stats

## Example output:
## CONTAINER        CPU %   MEM         DISK        INODES
## b1c2d3e4f5g6     0.15    25.6MB      12.4kB      15
## h7i8j9k0l1m2     0.08    18.2MB      8.2kB       12

## Show stats for a specific container
crictl stats b1c2d3e4f5g6

## Show stats for all containers (including stopped)
crictl stats -a

## Output stats in JSON format
crictl stats -o json

## Output stats in YAML format
crictl stats -o yaml

## Filter stats by label
crictl stats --label io.kubernetes.container.name=nginx

## Show stats by container ID
crictl stats --id b1c2d3e4f5g6

## Show resource usage for all pods (aggregated)
crictl statsp

## Example output:
## POD                                CPU %   MEM
## a1b2c3d4e5f6                       0.23    43.8MB
## f6e5d4c3b2a1                       0.08    18.2MB

## Show stats for a specific pod
crictl statsp --id a1b2c3d4e5f6

## Filter pod stats by label
crictl statsp --label app=nginx

## Output pod stats in JSON format
crictl statsp -o json

## Find the container using the most memory
## (using JSON output and jq for sorting)
crictl stats -o json | jq -r '.stats | sort_by(.memory.workingSetBytes.value) | reverse | .[] | "\(.attributes.id[0:12]) \(.attributes.labels["io.kubernetes.container.name"]) \(.memory.workingSetBytes.value / 1048576)MB"'

## Find the container using the most CPU
crictl stats -o json | jq -r '.stats | sort_by(.cpu.usageCoreNanoSeconds.value) | reverse | .[] | "\(.attributes.id[0:12]) \(.attributes.labels["io.kubernetes.container.name"]) CPU: \(.cpu.usageCoreNanoSeconds.value)"'

## Monitor stats continuously (watch mode)
## Use the 'watch' command to refresh stats every 2 seconds
watch -n 2 crictl stats

## Monitor a specific container continuously
watch -n 2 crictl stats --id b1c2d3e4f5g6

## Show the CRI version and the container runtime version
crictl version

## Example output:
## Version:  0.1.0
## RuntimeName:  containerd
## RuntimeVersion:  v1.7.11
## RuntimeApiVersion:  v1

## Show detailed runtime information (configuration, features, status)
crictl info

## Pretty-print the runtime info
crictl info | jq .

## Get the runtime's storage driver
crictl info | jq '.config.containerd.snapshotter'

## Get the runtime's CNI configuration
crictl info | jq '.config.cni'

## Get the runtime's cgroup driver
crictl info | jq '.config.containerd.runtimes.runc.options.SystemdCgroup'

## Check if the runtime is ready
crictl info | jq '.status.conditions'

## Example output for conditions:
## [
##   { "type": "RuntimeReady", "status": true, "reason": "", "message": "" },
##   { "type": "NetworkReady", "status": true, "reason": "", "message": "" }
## ]

## Check the runtime status conditions
## This tells you if the runtime and network plugins are healthy
crictl info | jq '.status'

## Check specifically if RuntimeReady is true
crictl info | jq '.status.conditions[] | select(.type=="RuntimeReady")'

## Check specifically if NetworkReady is true
crictl info | jq '.status.conditions[] | select(.type=="NetworkReady")'

## Check if the runtime socket exists and is accessible
ls -la /run/containerd/containerd.sock

## Check if the containerd service is running
systemctl status containerd

## Check containerd logs for errors
journalctl -u containerd --since "10 minutes ago" --no-pager

## For CRI-O:
systemctl status crio
journalctl -u crio --since "10 minutes ago" --no-pager

## Check the kubelet logs for CRI-related errors
journalctl -u kubelet --since "10 minutes ago" --no-pager | grep -i "cri\|runtime\|container"

## Verify the CRI socket permissions
stat /run/containerd/containerd.sock

## Test connectivity to the runtime socket directly
crictl --runtime-endpoint unix:///run/containerd/containerd.sock version

## First, create a pod sandbox configuration file
cat <<EOF > /tmp/pod-sandbox-config.json
{
  "metadata": {
    "name": "debug-sandbox",
    "namespace": "default",
    "attempt": 1,
    "uid": "debug-sandbox-uid-001"
  },
  "log_directory": "/tmp/debug-sandbox-logs",
  "linux": {}
}
EOF

## Create the log directory
mkdir -p /tmp/debug-sandbox-logs

## Create (run) the pod sandbox
## The 'runp' command creates and starts a new pod sandbox
SANDBOX_ID=$(crictl runp /tmp/pod-sandbox-config.json)
echo "Created sandbox: $SANDBOX_ID"

## Verify the sandbox was created
crictl pods --name debug-sandbox

## Inspect the sandbox
crictl inspectp $SANDBOX_ID | jq .

## Create a container configuration file
cat <<EOF > /tmp/container-config.json
{
  "metadata": {
    "name": "debug-container"
  },
  "image": {
    "image": "docker.io/library/busybox:latest"
  },
  "command": [
    "/bin/sh", "-c", "echo 'Hello from crictl debug container!' && sleep 3600"
  ],
  "log_path": "debug-container.log",
  "linux": {}
}
EOF

## Make sure the image is available locally
crictl pull busybox:latest

## Create the container (does NOT start it yet)
## Arguments: container-config sandbox-config sandbox-id
CONTAINER_ID=$(crictl create $SANDBOX_ID /tmp/container-config.json /tmp/pod-sandbox-config.json)
echo "Created container: $CONTAINER_ID"

## Verify the container was created (state = Created)
crictl ps -a --id $CONTAINER_ID

## Start the container
crictl start $CONTAINER_ID

## Verify the container is now running
crictl ps --id $CONTAINER_ID

## View the container logs
crictl logs $CONTAINER_ID

## Execute a command inside the container
crictl exec $CONTAINER_ID hostname

## Open an interactive shell
crictl exec -it $CONTAINER_ID /bin/sh

## Stop the container
crictl stop $CONTAINER_ID

## Remove the container
crictl rm $CONTAINER_ID

## Stop the pod sandbox
crictl stopp $SANDBOX_ID

## Remove the pod sandbox
crictl rmp $SANDBOX_ID

## Verify everything is cleaned up
crictl pods --name debug-sandbox
crictl ps -a --id $CONTAINER_ID

## Remove the temporary config files
rm -f /tmp/pod-sandbox-config.json /tmp/container-config.json
rm -rf /tmp/debug-sandbox-logs

## List all manually created sandboxes (ones not managed by kubelet)
## These typically have simple names like "debug-sandbox" or "test-pod"
crictl pods

## Stop and remove any manual sandboxes
## Replace <sandbox-id> with the actual ID
crictl stopp <sandbox-id>
crictl rmp <sandbox-id>

## Clean up any stopped containers that you created
crictl ps -a --state Exited

## Remove stopped containers by ID
crictl rm <container-id>

## Remove specific test images
crictl rmi busybox:latest
crictl rmi alpine:3.19
crictl rmi nginx:alpine

## Or prune all unused images
crictl rmi --prune

## Restore the standard crictl configuration
sudo tee /etc/crictl.yaml <<EOF
runtime-endpoint: unix:///run/containerd/containerd.sock
image-endpoint: unix:///run/containerd/containerd.sock
timeout: 10
debug: false
EOF

## Clean up temporary config files
rm -f /tmp/pod-sandbox-config.json
rm -f /tmp/container-config.json
rm -f /tmp/test-sandbox.json
rm -f /tmp/test-container.json
rm -rf /tmp/debug-sandbox-logs
rm -rf /tmp/test-pod-logs

## Check if crictl exists anywhere on the system
find / -name "crictl" -type f 2>/dev/null

## If found but not in PATH, add it
export PATH=$PATH:/usr/local/bin

## Check which sockets exist on the system
ls -la /run/containerd/containerd.sock 2>/dev/null
ls -la /var/run/crio/crio.sock 2>/dev/null
ls -la /run/cri-dockerd.sock 2>/dev/null

## Check if containerd is running
systemctl status containerd

## Update /etc/crictl.yaml with the correct socket path

## Run with sudo
sudo crictl ps

## Or check socket permissions
ls -la /run/containerd/containerd.sock

## The socket should be owned by root:root with permissions srw-rw----
## You can add your user to the appropriate group if needed

## Check which runtime the kubelet is using
ps aux | grep kubelet | grep container-runtime-endpoint

## Verify your crictl configuration matches
cat /etc/crictl.yaml

## Try specifying the endpoint explicitly
crictl --runtime-endpoint unix:///run/containerd/containerd.sock pods

## Increase the timeout in /etc/crictl.yaml
sudo sed -i 's/timeout: 10/timeout: 30/' /etc/crictl.yaml

## Or pass a longer timeout on the command line
crictl --timeout 30 ps

## Check the runtime's health
systemctl status containerd
journalctl -u containerd --since "5 minutes ago" --no-pager

## Debian/Ubuntu
sudo apt-get install -y jq

## RHEL/CentOS/Fedora
sudo yum install -y jq

## Alpine
sudo apk add jq

## Restart the container runtime
sudo systemctl restart containerd

## Check the runtime logs for errors
journalctl -u containerd --since "10 minutes ago" --no-pager

## Verify the runtime recovers
crictl info | jq '.status.conditions'

## Check CNI configuration files
ls -la /etc/cni/net.d/

## Check CNI binary directory
ls -la /opt/cni/bin/

## Check kubelet logs for CNI errors
journalctl -u kubelet --since "10 minutes ago" --no-pager | grep -i cni

## Restart the kubelet to re-initialize networking
sudo systemctl restart kubelet