Containerization Interview Questions: OCI, Podman (2027)

70 containerization interview questions beyond Docker: OCI specs, containerd, CRI-O, Podman, rootless, signing, SBOMs and moving to Kubernetes or ECS.

Sep 10, 2025 - 14:36
Nov 8, 2026 - 12:16
 0  101
Containerization Interview Questions: OCI, Podman (2027)

Containerization interview questions go past the Docker CLI. Interviewers want to know how containers work underneath: OCI image and runtime specs, Linux namespaces and cgroups, containerd, runc and CRI-O, daemonless tools like Podman and Buildah, rootless containers, image signing and SBOMs, and how a Docker workload moves to Kubernetes or Amazon ECS. This page has 70 questions with direct answers, grouped by level, plus scenario questions.

This post is the "beyond Docker" companion to our main 100+ Docker scenario-based interview questions. If you need Docker basics first, start with 100+ Docker interview questions on core concepts, and for a short senior list see 15 most common Docker interview questions for experienced engineers. The questions below avoid repeating those and focus on the container ecosystem as a whole.

Key takeaways

  • Docker is one implementation of open standards. The Open Container Initiative (OCI) defines three specs: image, runtime and distribution.
  • A container is an ordinary Linux process isolated with namespaces, limited with cgroups and restricted with capabilities, seccomp and an LSM such as SELinux or AppArmor.
  • Kubernetes talks to runtimes through the Container Runtime Interface (CRI). Since dockershim was removed in Kubernetes v1.24, clusters use containerd or CRI-O directly; images built with Docker still run because they are OCI images.
  • Podman, Buildah and Skopeo cover running, building and copying images without a long-running daemon, and Podman runs rootless by default for normal users.
  • Supply chain questions now appear at every level: SBOMs (SPDX, CycloneDX), provenance attestations, signing with Sigstore cosign or Notation, and admission policies that verify signatures.
  • Migration questions test whether you can map Compose concepts to Kubernetes objects or ECS task definitions, including health checks, signals, logging and secrets.

How this page fits with the other Docker guides

GuideFocusUse it when
Docker scenario-based questionsTroubleshooting Docker containers, builds and networksYou need hands-on debugging practice
Docker core conceptsDockerfile, CLI, Compose, networking basicsYou are a fresher or new to Docker
15 most common (experienced)Short senior shortlistYou want a quick revision before an interview
This pageOCI, runtimes, Podman, rootless, supply chain, migration to Kubernetes and ECSThe role says "containers" or "platform", not only "Docker"

Freshers: container fundamentals beyond Docker (1-22)

1. What is the Open Container Initiative?

The OCI is a Linux Foundation project that publishes open specifications for container formats and runtimes. It was started in 2015 with Docker donating its image format and runtime code. Because tools follow the same specs, an image built with Docker can be run by Podman, containerd or CRI-O.

2. Which specifications does the OCI publish?

Three: the image spec (how an image's manifest, config and layers are laid out), the runtime spec (how a filesystem bundle and a config.json become a running container) and the distribution spec (the HTTP API registries use to push and pull content).

3. What does an OCI image contain?

A manifest that lists content by digest, a config JSON (environment, entrypoint, user, working directory, layer diff IDs) and one or more filesystem layers, usually gzip or zstd compressed tar archives. Multi-platform images add an image index that points to one manifest per OS and architecture.

4. What is a container runtime?

Software that creates and runs containers. People use the word for two layers: a low-level runtime such as runc or crun that sets up namespaces and cgroups and starts the process, and a high-level runtime such as containerd or CRI-O that pulls images, manages storage and snapshots, and calls the low-level runtime.

5. What is runc?

runc is the reference implementation of the OCI runtime spec, written in Go. It takes an OCI bundle (a root filesystem plus config.json) and starts the container. Docker, containerd and CRI-O use it by default on Linux.

6. What is containerd?

containerd is a CNCF graduated container runtime that manages the full container lifecycle on a host: image pull and storage, snapshots, execution through runc and networking hooks. Docker Engine uses containerd internally, and Kubernetes can use it directly through its CRI plugin.

7. What is CRI-O?

CRI-O is a lightweight runtime built only for Kubernetes. It implements the CRI and nothing else, uses OCI runtimes such as runc or crun, and versions itself in step with Kubernetes minor releases. Red Hat OpenShift uses CRI-O.

8. What is the Container Runtime Interface (CRI)?

The CRI is a gRPC API between the kubelet and a container runtime. It has two services: RuntimeService for pod sandboxes and containers, and ImageService for pulling and listing images. Any runtime that implements it can back a Kubernetes node.

9. Which Linux namespaces isolate a container?

Mount, PID, network, UTS (hostname), IPC, user and cgroup namespaces. Linux also has a time namespace, but common container engines do not create one by default. Each namespace gives the process its own view of one kind of system resource.

10. What do cgroups do for containers?

Control groups limit and account for resources: CPU, memory, block I/O and the number of processes. A memory limit is enforced by the kernel, which is why a container that goes over it is killed by the out-of-memory killer. Most current distributions use the unified cgroup v2 hierarchy.

11. Is a container a lightweight virtual machine?

No. A container shares the host kernel and is a process with restricted views and limits. A virtual machine runs its own kernel on a hypervisor. That shared kernel is why kernel vulnerabilities matter more for containers and why sandboxed runtimes exist.

12. What is Podman?

Podman is a daemonless container engine from the containers project. Its CLI is largely compatible with Docker's (podman run, podman build, podman ps), each container runs as a child of the command or of systemd rather than of a central daemon, and normal users run rootless containers by default.

13. What are Buildah and Skopeo?

Buildah builds OCI images, either from a Containerfile or Dockerfile or step by step from shell commands, without a daemon. Skopeo inspects, copies and deletes images in remote registries without pulling them into local storage, which is handy for mirroring images between registries.

14. What is a Containerfile?

The same thing as a Dockerfile under a vendor-neutral name. Podman and Buildah look for Containerfile first and fall back to Dockerfile. The instruction syntax is the same.

15. What is a pod in Podman?

A group of containers that share network and some other namespaces, modelled on the Kubernetes pod. Podman uses an infra container to hold the shared namespaces. Pods make it easy to test a multi-container layout locally before moving it to Kubernetes.

16. What are nerdctl, ctr and crictl?

nerdctl is a Docker-compatible CLI for containerd, including Compose support. ctr is containerd's low-level debugging client and is not meant for daily use. crictl is a CLI for any CRI runtime and is the tool you use on a Kubernetes node to list pods, containers and images.

17. What is an image digest and why do runtimes prefer it?

A digest such as sha256:... is the hash of the manifest. It identifies content exactly, while a tag like 1.2 can be moved to different content. Pinning by digest gives reproducible deploys and is what signatures and attestations refer to.

18. What is an OCI artifact?

Content other than a runnable image stored in an OCI registry, such as a Helm chart, an SBOM, a signature or a WebAssembly module. OCI image spec v1.1 added the artifactType and subject fields so artifacts can be typed and linked to the image they describe.

19. Can a container image built on a laptop run on any server?

Only if the CPU architecture and OS match, or if the image is multi-platform. An arm64 image will not run natively on an amd64 node. Build for each target platform and publish an image index.

20. What is a sandboxed runtime?

A runtime that adds an extra isolation boundary between the container and the host kernel. gVisor (runsc) intercepts system calls in a user-space kernel, and Kata Containers runs each pod inside a lightweight VM. Both are OCI-compatible, so Kubernetes can select them with a RuntimeClass.

21. What are Linux capabilities in containers?

Root's powers split into units such as CAP_NET_BIND_SERVICE or CAP_SYS_ADMIN. Engines start containers with a reduced default set. Good practice is to drop all and add back only what the app needs.

22. What is seccomp?

A kernel feature that filters which system calls a process may make. Docker and Podman apply a default seccomp profile that blocks rarely needed, risky calls. In Kubernetes you request it with securityContext.seccompProfile.type: RuntimeDefault.

2-5 years: runtimes, rootless and image builds (23-46)

23. Walk through what happens on a Kubernetes node when a pod is scheduled.

The kubelet sees the pod, calls the CRI RunPodSandbox to create the sandbox and network namespace (the CNI plugin attaches networking), pulls images through ImageService, then calls CreateContainer and StartContainer. containerd or CRI-O prepares the root filesystem with a snapshotter or storage driver and invokes runc, which creates namespaces and cgroups and runs the entrypoint.

24. What did the removal of dockershim change?

Kubernetes v1.24 removed dockershim, the built-in adapter that let the kubelet drive Docker Engine. Nodes must now run a CRI runtime such as containerd or CRI-O, or use the separately maintained cri-dockerd adapter to keep Docker Engine. Images and registries did not change, because they are OCI-compatible.

25. Why might a team choose CRI-O over containerd for Kubernetes?

CRI-O has a narrow scope (only Kubernetes), its releases track Kubernetes versions, and it is the default on OpenShift. containerd is more general purpose, is used by Docker and many managed Kubernetes services, and has a larger plugin system. Both run OCI images through runc or another OCI runtime.

26. What is a containerd snapshotter?

The component that prepares layered filesystems for containers. The default is overlayfs. Others include native, btrfs, zfs and lazy-pulling snapshotters such as stargz, which start a container before the whole image is downloaded.

27. What is a containerd shim?

A small process (for example containerd-shim-runc-v2) that sits between containerd and each container. It keeps the container's stdio and exit status, so containerd can restart or upgrade without killing running containers.

28. How does rootless mode work?

The engine and containers run as a normal user. A user namespace maps container UID 0 to the user's UID, and extra UIDs come from ranges in /etc/subuid and /etc/subgid, applied by newuidmap and newgidmap. Networking runs in user space through tools such as slirp4netns, pasta or RootlessKit, because an unprivileged user cannot create host network interfaces.

29. What are the limits of rootless containers?

Binding ports below 1024 needs extra configuration, user-space networking can be slower, some storage drivers and cgroup controls need cgroup v2 with delegation, and anything needing real host privileges (loading kernel modules, some device access) will not work. Check the engine's rootless documentation for the current list.

30. How do you set up rootless Docker?

Install the rootless extras package, make sure subordinate UID and GID ranges exist for the user, then run dockerd-rootless-setuptool.sh install as that user. Point the client at the user's socket, usually through DOCKER_HOST=unix://$XDG_RUNTIME_DIR/docker.sock or a Docker context.

31. Rootless containers versus running as a non-root user inside the container: what is the difference?

The USER instruction makes the app process non-root inside the container, but the engine may still run as root on the host. Rootless mode makes the engine itself unprivileged, so even a container breakout lands as a normal host user. The two are complementary.

32. How does Podman integrate with systemd?

Through Quadlet: you write .container, .pod, .volume or .kube unit files and systemd generates the services. Podman's documentation recommends Quadlet over the older podman generate systemd command.

# ~/.config/containers/systemd/web.container
[Container]
Image=docker.io/library/nginx:1.27
PublishPort=8080:80

[Install]
WantedBy=default.target

33. How can Podman help you move to Kubernetes?

podman kube generate writes Kubernetes YAML from an existing container or pod, and podman kube play runs Kubernetes Pod, Deployment and some other manifests locally. It is a quick way to test manifests without a cluster.

34. Can Docker Compose files run with Podman?

Yes, in most cases. Podman exposes a Docker-compatible API socket, so docker compose can talk to it, and podman compose wraps an external Compose provider. Test features like networks and volume permissions, which can differ in rootless mode.

35. How do you build images in CI without giving the job a privileged Docker daemon?

Options include rootless BuildKit, Buildah in rootless mode, or a remote BuildKit builder reached through docker buildx. Mounting the host's Docker socket into a CI job gives that job root-equivalent control over the host and should be avoided.

36. What is BuildKit outside Docker?

BuildKit is the build engine behind docker build, but it also runs standalone as buildkitd with the buildctl client, including a rootless mode. It supports parallel stages, cache import and export, secrets and SSH mounts, and multi-platform output.

37. How do you produce a multi-platform image?

With Buildx you run docker buildx build --platform linux/amd64,linux/arm64 -t registry/app:1.0 --push .. The result is an image index pointing to one manifest per platform. Builds for a foreign architecture use QEMU emulation or native remote builders.

38. What is the difference between a distroless image and a scratch image?

scratch is an empty image, useful for static binaries such as Go programs. Distroless images contain a minimal runtime (CA certificates, timezone data, sometimes a language runtime) but no shell or package manager. Both cut attack surface, at the cost of harder interactive debugging.

39. How do you debug a container that has no shell?

In Kubernetes, use kubectl debug to attach an ephemeral container that shares the target's process namespace. On a single host, run a tools container in the target's namespaces, for example docker run -it --pid=container:app --network=container:app busybox.

40. How does user namespace remapping differ from rootless mode?

With userns-remap, the Docker daemon still runs as root but container UIDs map to an unprivileged range on the host. In rootless mode the daemon itself runs as a normal user. Kubernetes has its own user namespace support for pods through hostUsers: false; check the feature state for your cluster version.

41. What does SELinux add to container isolation?

On RHEL-family hosts each container process gets an SELinux label (for example container_t) and a unique category pair, so a compromised container cannot read other containers' files even as root. Volume mounts need relabelling, which Podman and Docker do with the :z or :Z mount option.

42. How do you pull images when Docker Hub rate limits or blocks you?

Mirror needed images into a private registry (Harbor, Amazon ECR, Artifactory and others) with Skopeo or a pull-through cache, configure registry mirrors in containerd or registries.conf for Podman and CRI-O, and authenticate pulls. See our guide to container registries for options.

43. How are short image names resolved outside Docker?

Docker always expands nginx to docker.io/library/nginx. Podman and CRI-O use registries.conf, which may list several search registries or use short-name aliases. Fully qualified names avoid pulling a lookalike image from the wrong registry.

44. What does Kubernetes do with a Dockerfile HEALTHCHECK?

Nothing. Kubernetes ignores the image's HEALTHCHECK and uses the liveness, readiness and startup probes defined in the pod spec. Amazon ECS also uses the healthCheck in the task definition rather than the image's instruction.

45. How do ENTRYPOINT and CMD map into Kubernetes?

command in the container spec overrides the image ENTRYPOINT, and args overrides CMD. If you set only args, the image's ENTRYPOINT runs with your arguments.

46. What is the containerd image store in Docker?

A mode where Docker Engine keeps images in containerd's content store and snapshotters instead of its own graph drivers. It lets Docker store multi-platform images and attestations natively. Docker made it the default for new installations in recent Engine releases; check the release notes for your version.

Senior: supply chain, policy and platform design (47-60)

47. What is an SBOM and which formats are standard?

A software bill of materials lists the packages and versions inside an image. The two common formats are SPDX (an ISO/IEC standard, 5962:2021) and CycloneDX (an OWASP project, also published as ECMA-424). Scanners such as Syft generate them, and BuildKit can attach one with --sbom=true.

48. What is a provenance attestation?

A signed statement of how an artifact was built: source repository and commit, builder, build parameters. The SLSA framework defines provenance levels. BuildKit can emit SLSA provenance with --provenance=mode=max, and CI systems such as GitHub Actions can produce signed provenance too.

49. How do you sign container images?

Two common tools: Sigstore cosign, which supports key pairs and keyless signing with short-lived certificates from Fulcio and a transparency log in Rekor, and Notation from the CNCF Notary Project, which uses X.509 certificates. Both store signatures as OCI artifacts next to the image and sign the digest, not the tag.

cosign sign registry.example.com/app@sha256:<digest>
cosign verify registry.example.com/app@sha256:<digest> \
  --certificate-identity=<signer> --certificate-oidc-issuer=<issuer>

50. How do you enforce signed images in Kubernetes?

Use an admission controller that checks signatures before pods are admitted: Sigstore policy-controller, Kyverno verifyImages rules, or Ratify with OPA Gatekeeper for Notation signatures. Pair it with policies that require digests and approved registries.

51. What is the referrers API?

Part of OCI distribution spec v1.1. A client can ask a registry for all artifacts whose subject points to a given manifest, which is how tools find an image's signatures and SBOMs. Registries that do not support it can fall back to a tag naming scheme.

52. How would you design a container image pipeline for a regulated team?

Approved base images only, rebuilt on a schedule; builds in isolated CI runners with no Docker socket; SBOM and provenance attached at build time; vulnerability scan with a policy gate; signing in CI with an identity tied to the pipeline; promotion between registries by digest; admission control that verifies signature and registry in every cluster; and runtime monitoring for drift.

53. How do Kubernetes Pod Security Standards relate to container hardening?

They define three levels, privileged, baseline and restricted, enforced by the built-in Pod Security Admission controller per namespace. Restricted requires non-root users, dropping all capabilities, a seccomp profile and no privilege escalation, which is the Kubernetes form of the hardening you would do with Docker flags.

securityContext:
  runAsNonRoot: true
  allowPrivilegeEscalation: false
  readOnlyRootFilesystem: true
  capabilities:
    drop: ["ALL"]
  seccompProfile:
    type: RuntimeDefault

54. When would you use gVisor or Kata Containers?

For untrusted or multi-tenant workloads where a shared kernel is too much risk, such as running customer code. You trade some performance and compatibility for the extra boundary. In Kubernetes, define a RuntimeClass per handler and set runtimeClassName on the pods that need it.

apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: gvisor
handler: runsc

55. How do you choose between Docker, Podman and containerd for developer machines and servers?

Match the tool to the job. Docker Desktop or Docker Engine gives the widest tooling and Compose support (check Docker's licence terms for larger companies). Podman suits RHEL-family servers and rootless, daemonless use with systemd. containerd with nerdctl suits teams who want the same runtime locally as on their Kubernetes nodes.

56. How do you keep Helm charts and other artifacts in the same registry as images?

Helm 3.8 and later support OCI registries natively (helm push and oci:// references). ORAS handles arbitrary artifacts. Storing everything in one registry gives one place for access control, replication and signing.

57. What runtime signals tell you a container platform is unhealthy?

Image pull latency and failures, container restart counts and OOM kills, node disk pressure from image and log growth, CRI errors in kubelet logs, and cgroup memory and CPU throttling metrics. Tools such as cAdvisor (built into the kubelet) expose most of these to Prometheus.

58. How do you reduce cold-start time for large images?

Smaller images first, then pre-pulling on nodes, keeping frequently used base layers stable so they stay cached, and lazy-pulling snapshotters such as stargz or SOCI (on AWS) that fetch only the files needed at start.

59. How does garbage collection of images work on Kubernetes nodes?

The kubelet removes unused images when disk usage crosses imageGCHighThresholdPercent and stops at imageGCLowThresholdPercent. Container runtimes also clean up exited containers. You can inspect images on the node with crictl images.

60. How do you explain the container stack to a non-specialist manager?

The image is a sealed package following an open standard. The runtime (containerd or CRI-O plus runc) opens and runs that package on a server. Kubernetes or ECS decides which server runs it and keeps it running. Docker and Podman are developer tools for building and testing packages.

Migration: Docker to Kubernetes and Amazon ECS (61-66)

61. How do Compose concepts map to Kubernetes objects?

ComposeKubernetesAmazon ECS
serviceDeployment (or StatefulSet) plus ServiceService running a task definition
image, command, environmentcontainer spec: image, command/args, envcontainerDefinitions
portsService, Ingress or GatewayportMappings plus load balancer target group
volumesPersistentVolumeClaim, ConfigMap, emptyDirvolumes (EFS, bind, Docker volumes on EC2)
secretsSecret (ideally from an external store)secrets from Secrets Manager or SSM Parameter Store
healthcheckliveness, readiness, startup probeshealthCheck in the container definition
deploy.replicasreplicas or HorizontalPodAutoscalerdesiredCount and Service Auto Scaling

Kompose can generate a first draft of Kubernetes YAML from a Compose file, but review the output by hand.

62. What breaks most often when a Docker app moves to Kubernetes?

Assumptions about the host: writing to local disk, fixed IPs, depends_on ordering, running as root (blocked by restricted policies), relying on HEALTHCHECK, ignoring SIGTERM, and secrets baked into images. Each needs an explicit Kubernetes replacement.

63. How should an app handle shutdown on Kubernetes and ECS?

Both send SIGTERM, wait a grace period, then send SIGKILL. Kubernetes uses terminationGracePeriodSeconds (default 30 seconds); ECS uses the container stopTimeout. The app should run as PID 1 or behind a small init, catch SIGTERM, stop accepting traffic and finish in-flight work.

64. What does an ECS task definition need that Compose does not?

A launch type or capacity provider (EC2 or Fargate), a network mode (Fargate requires awsvpc), task-level CPU and memory for Fargate, a task execution role to pull from ECR and read secrets, a task role for the app's own AWS calls, and a log configuration such as awslogs.

{
  "family": "web",
  "requiresCompatibilities": ["FARGATE"],
  "networkMode": "awsvpc",
  "cpu": "256",
  "memory": "512",
  "executionRoleArn": "arn:aws:iam::<account>:role/ecsTaskExecutionRole",
  "containerDefinitions": [{
    "name": "web",
    "image": "<account>.dkr.ecr.<region>.amazonaws.com/web@sha256:<digest>",
    "portMappings": [{ "containerPort": 8080 }],
    "essential": true,
    "logConfiguration": {
      "logDriver": "awslogs",
      "options": {
        "awslogs-group": "/ecs/web",
        "awslogs-region": "<region>",
        "awslogs-stream-prefix": "web"
      }
    }
  }]
}

65. ECS or EKS for a team moving off plain Docker hosts?

ECS is AWS-specific but has fewer moving parts and no control plane to upgrade, which suits small teams with straightforward services. EKS gives the Kubernetes API, its ecosystem (Helm, operators, GitOps) and portability, at the cost of more to learn and operate. Both run the same OCI images from ECR.

66. How do you migrate stateful containers?

Move state out first if you can (managed database, object storage). If state must stay in containers, use a StatefulSet with PersistentVolumeClaims backed by a CSI driver on Kubernetes, or EFS volumes on ECS, and rehearse backup and restore before cutover.

Scenario questions (67-70)

67. After a cluster upgrade, nodes fail because the runtime was Docker Engine. What do you do?

The kubelet no longer includes dockershim. The cleanest fix is to switch the nodes to containerd (or CRI-O), set the kubelet's container runtime endpoint to the new socket, and drain and rejoin nodes one by one. If something truly depends on Docker Engine on the node, install cri-dockerd as a stop-gap. Check that nothing mounts /var/run/docker.sock, since that socket goes away.

68. A pod is rejected by admission with "image signature verification failed". How do you work through it?

Confirm the pod references the image by the same digest that was signed, not a retagged copy. Check that the signature exists in the registry (for example cosign tree or cosign verify), that the policy's expected identity and issuer match the CI signer, and that the cluster can reach the registry's referrers or signature tags. Fix the pipeline rather than adding an exception.

69. A rootless Podman container cannot write to a bind-mounted directory. Why?

Inside the container, UID 0 maps to your host user, and other container UIDs map into your subordinate range, so files owned by your user can look like root's and the app user may not own them. On SELinux hosts the directory may also lack the right label. Use podman unshare chown to fix ownership within your namespace, the :Z option for labelling, or --userns=keep-id so your UID is the same inside.

70. A scan finds a critical CVE in the base image of 40 services. How do you handle it?

Use SBOMs to list exactly which images and versions contain the package, check whether the vulnerable code is reachable, and patch the shared base image. Rebuild dependants automatically, sign and promote the new digests, and roll out through normal deployments. Track the rollout by digest so you can prove every service moved.

How to practise these topics

  • Run the same image with Docker, Podman and nerdctl and compare where each stores images.
  • On a test Kubernetes node, use crictl ps, crictl inspect and crictl images instead of the Docker CLI.
  • Generate an SBOM and provenance for an image with Buildx, sign it with cosign, and verify it.
  • Convert a three-service Compose file into Kubernetes manifests and an ECS task definition by hand.

For the runtime and Docker basics, read what Docker is and why it is popular in DevOps and when to use containerd instead of Docker in Kubernetes. For cluster-side troubleshooting, continue with Kubernetes scenario-based interview questions.

If you want guided labs on images, runtimes and Compose, see our Docker training in Pune (classroom in Kharadi or live online). For the Kubernetes side, the CKA training covers runtimes, pods and cluster operations.

Frequently asked questions

What is the difference between Docker and containerization?

Containerization is the general technique of packaging an app with its dependencies and running it as an isolated process. Docker is one popular toolset for doing it. Podman, containerd and CRI-O are others, and all follow the OCI specifications.

Do I need to learn Podman if I already know Docker?

Learn the basics. The commands are mostly the same, and many RHEL-based and security-focused teams prefer Podman for rootless, daemonless use. Knowing both shows you understand containers rather than one tool.

Do Docker images work on Kubernetes without Docker?

Yes. Docker builds OCI-compatible images, and containerd and CRI-O run them. Removing dockershim in Kubernetes v1.24 changed the node runtime, not the image format.

What is the difference between runc and containerd?

runc is a low-level runtime that creates one container from an OCI bundle and exits. containerd is a daemon that manages images, storage and the lifecycle of many containers and calls runc to start each one.

What container supply chain topics come up in interviews?

SBOM formats (SPDX, CycloneDX), provenance and SLSA, signing with cosign or Notation, verifying signatures at admission, pinning images by digest and patching base images across many services.

Is rootless mode the same as running a container as non-root?

No. A non-root USER limits the app inside the container. Rootless mode runs the container engine itself as an unprivileged user, which limits damage if a container escapes.

Should I move from Docker hosts to ECS or EKS?

Choose ECS for fewer moving parts on AWS, and EKS when you need the Kubernetes API, its ecosystem or portability. Both run the same OCI images from ECR.

Official references

What's Your Reaction?

Like Like 0
Dislike Dislike 0
Love Love 0
Funny Funny 0
Angry Angry 0
Sad Sad 0
Wow Wow 0
Mridul I am a passionate technology enthusiast with a strong focus on DevOps, Cloud Computing, and Cybersecurity. Through my blogs at DevOps Training Institute, I aim to simplify complex concepts and share practical insights for learners and professionals. My goal is to empower readers with knowledge, hands-on tips, and industry best practices to stay ahead in the ever-evolving world of DevOps.