Red Hat Certified Specialist in Containers and Kubernetes Free Practice Questions
This practice bank reinforces core skills for building, managing, and orchestrating containers using Podman and Kubernetes. Questions exercise foundational knowledge of container images, Podman CLI, Kubernetes Pods and Services, configuration injection via ConfigMaps, and security scanning. You must understand the lifecycle of ephemeral storage (EmptyDir), resource constraints (CPU shares), health probes (readiness), and the purpose of registries and namespaces. Decisions include choosing the correct command for image builds, pulls, and listing containers, interpreting declarative management with Deployments, and applying best practices for isolating configurations and sensitive data. Mastery of these topics is essential for the Red Hat Certified Specialist exam.
What this Red Hat Certified Specialist in Containers and Kubernetes practice set measures
This is an analysis of the practice bank, not a claim about the vendor's live exam blueprint. Use it to identify the knowledge, judgment, and recall patterns exercised here, then verify your coverage against the current official exam guide.
Container Image Fundamentals and Management
Understanding what a container image is and how it is created and distributed forms the bedrock of containerized environments. The practice bank tests the primary purpose of an image as a portable artifact packaging code, runtime, and dependencies. You must know how to build an image from a Dockerfile using podman build and pull images from a registry with podman pull. The role of a container registry as a storage and distribution point is also assessed. These concepts are prerequisites for consistent deployment across different environments and align with Red Hat's container strategy.
- A container image is a lightweight, standalone executable that includes everything needed to run a piece of software.
- Podman build and podman pull are the primary commands for building and downloading images.
- A registry (e.g., quay.io or registry.redhat.io) stores and versions container images for sharing.
- Dockerfile (or Containerfile) defines the build steps including base image, layers, and entrypoint.
Podman Command Line Operations
Proficiency with the Podman command line is essential for day-to-day container administration. The practice bank covers listing running containers (podman ps), building images, and pulling images. These commands are analogous to Docker commands and are central to Red Hat's container tooling. You must be able to create containers, manage their lifecycle, and inspect their status quickly. Understanding the options for resource constraints (e.g., CPU shares) and state management prepares you for real-world administration tasks.
- podman ps shows running containers; use -a to include stopped ones.
- podman build reads a Dockerfile and produces an image tagged locally.
- podman pull fetches an image from a registry, optionally with version tags.
- Resource limits like CPU shares control how CPU time is allocated among containers.
Kubernetes Pod, Service, and Workload Management
Kubernetes orchestrates containers at scale, and the practice bank tests core building blocks. A Pod is the smallest deployable unit that can contain one or more containers sharing network and storage. Services provide stable endpoints for accessing Pods, enabling load balancing and service discovery. Deployments manage the desired state of Pods through ReplicaSets, supporting rolling updates and rollbacks. Readiness probes determine if a container is ready to serve traffic, which is crucial for high-availability applications.
- A Pod encapsulates containers that share the same network namespace and volumes.
- A Service abstracts access to a set of Pods via a stable IP and port.
- Deployments declaratively manage Pod replicas and support updates.
- Readiness probes control whether a Pod is included in Service endpoints.
Configuration, Storage, and Security Best Practices
Effective containerized applications depend on decoupled configuration, appropriate storage, and security measures. ConfigMaps inject non-sensitive data as environment variables or files. EmptyDir volumes provide ephemeral storage tied to a Pod's lifecycle. Security practices such as scanning images for vulnerabilities and avoiding running containers as root are emphasized. Namespaces logically isolate workloads within a Kubernetes cluster. Understanding these concepts ensures that applications are portable, resilient, and secure.
- ConfigMaps decouple configuration from image content for portability.
- EmptyDir volumes exist only while a Pod runs and are useful for scratch space.
- Scan container images for known vulnerabilities before deployment.
- Namespaces provide scope for resource names and enable multi-tenancy.
Practice Red Hat Certified Specialist in Containers and Kubernetes with real flashcards
Read the prompt, commit to an answer, then flip the card. Move through the deck at your own pace and repeat any topic that does not come back quickly.
Card 1 of 20
1 reviewed this session
Static practice bank
Start the 15-question diagnostic
The complete question bank is embedded in this pre-rendered page. There is no database request or second content download when you begin.
What is the primary purpose of a container image?
Show hint
Understand container image fundamentals
Study workflow
Turn one Red Hat Certified Specialist in Containers and Kubernetes attempt into a study plan
- 1
Master Podman CLI Commands
Practice using podman run, ps, build, pull, and push in a lab environment. Create Dockerfiles and build images with different base images. Use podman ps -a to list all containers including stopped ones. Set resource limits with --cpus and --memory to understand constraints. This hands-on experience solidifies the command syntax tested in the exam.
- 2
Deploy and Expose Applications on Kubernetes
Create a Deployment YAML that runs multiple replicas of a container image. Expose the Deployment using a Service (ClusterIP, NodePort, or LoadBalancer). Verify that the Service load-balances traffic across Pods. Add readiness and liveness probes to the Pod spec and observe how they affect Pod status in kubectl get pods.
- 3
Work with ConfigMaps and Secrets
Create a ConfigMap from literal values or files and mount it as volumes or environment variables in a Pod. Distinguish between ConfigMap and Secret usage. Practice updating a ConfigMap and checking if Pods pick up the changes (they may need a restart). This reinforces decoupling configuration from images.
- 4
Manage Ephemeral and Persistent Storage
In Kubernetes, create a Pod with an EmptyDir volume and write data to it; delete and recreate the Pod to confirm data loss. Then create a PersistentVolumeClaim (PVC) and use it in a Pod to persist data across Pod restarts. Understand the lifecycle differences and when to use each storage type.
- 5
Implement Security Scanning and Best Practices
Install a vulnerability scanner (e.g., Red Hat's docker registry scanning or Skopeo) and scan an image from a public registry. Review the report. Also, modify a Dockerfile to run the application as a non-root user and rebuild. Test that the container runs without privilege escalation. This practice aligns with the exam's security emphasis.
FAQ
Questions about this exam practice page
Clear boundaries on what the bank covers, how to use it, and where official vendor information still matters.
How do the Podman commands tested here differ from Docker commands on the Red Hat exam?+
Podman is often the default container engine on Red Hat Enterprise Linux 8 and later, but its CLI syntax is almost identical to Docker. The exam may use either, so familiarity with both is recommended. Commands like podman ps, build, pull, and run work the same way as their docker counterparts.
Why is EmptyDir considered ephemeral and when should I use it?+
EmptyDir volumes exist only while a Pod occupies a node. They are created fresh when a Pod starts and discarded when the Pod is deleted. Use EmptyDir for temporary scratch space, cache, or shared data between containers in the same Pod. For persistent data, use PersistentVolumeClaims.
What is the difference between a ConfigMap and a Secret?+
ConfigMaps store non-sensitive configuration data as key-value pairs, while Secrets store sensitive data like passwords or SSH keys. Secrets are encoded (not encrypted by default) and can be mounted as volumes or environment variables. Both allow decoupling configuration from container images, but Secrets have additional RBAC controls.
How does a readiness probe affect a Service's load balancing?+
A readiness probe determines if a Pod is ready to serve traffic. If the probe fails, the Pod is removed from the Service's endpoints, so no requests are routed to it. This prevents serving traffic to Pods that are still initializing or overwhelmed. The liveness probe, in contrast, restarts unhealthy containers.
What is the role of namespaces in the exam context?+
Namespaces logically divide a Kubernetes cluster into virtual sub-clusters. They provide isolation for resources (Pods, Services, etc.) and are used to separate environments (e.g., dev, test, prod) or teams. In Red Hat's OpenShift, projects are namespaces with additional annotations. Understanding namespaces is critical for multi-tenancy and resource quotas.
Build the next review session
Browse another free bank or use the study strategy guide to turn your misses into spaced review.