XK0-006 Automation, Orchestration, and Scripting Practice Test 2 — 15 Questions

Question 1

A containerized application uses a volume to persist data. The administrator needs to create a new volume named 'data-vol' and mount it to /app/data in the container. Which of the following commands accomplish this? (Select all that apply.)

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

docker run --mount type=volume,source=data-vol,target=/app/data myapp. Both options A and C are correct because they create the volume automatically if it doesn't exist and mount it to the container. The `--mount` flag (option A) uses a more explicit syntax compared to the `-v` flag (option C), but both achieve the same result. Option B is incorrect because the leading slash in `/data-vol` causes a bind mount from the host, not a named volume. Option D is incorrect because it uses two separate commands (`docker volume create` and `docker run`), while the question asks for a single command that both creates and mounts the volume.

Answer

docker run -v /data-vol:/app/data myapp

Answer

docker volume create data-vol && docker run -v data-vol:/app/data myapp

Question 2

An administrator needs to create a Docker network of type 'bridge' so that containers can communicate with each other by name. Which command creates a user-defined bridge network named 'my-net'?

Accepted Answer

docker network create -d bridge my-net. The command docker network create -d bridge my-net explicitly specifies the bridge driver and names the network 'my-net'. User-defined bridge networks provide automatic DNS resolution between containers, allowing them to reach each other by container name, which is the requirement stated in the question.

Answer

docker network create my-net

Answer

docker create network -d bridge my-net

Answer

docker network create --driver=overlay my-net

Question 3

A Linux administrator is writing a bash script to process a list of usernames stored in an array. The script must iterate over each username and print a welcome message. Which TWO of the following loops will correctly iterate over the array 'users' and print 'Welcome, <username>'? (Choose TWO.)

Accepted Answer

for ((i=0; i<${#users[@]}; i++)); do echo "Welcome, ${users[$i]}"; done. Arrays can be iterated using for with ${users[@]} or using indices. The correct methods are direct iteration over elements and using a C-style for loop with indices.

Answer

for user in $users; do echo "Welcome, $user"; done

Answer

for user in "${users[*]}"; do echo "Welcome, $user"; done

Answer

while read user; do echo "Welcome, $user"; done < <(printf '%s
' "${users[@]}")

Question 4

A DevOps engineer is writing a Bash script that iterates over all items in an array. The array is declared as 'fruits=("apple" "banana" "cherry")'. Which loop correctly iterates over each element?

Accepted Answer

for fruit in "${fruits[@]}"; do ... done. "${fruits[@]}" expands each array element as a separate word, preserving spaces and special characters, and the for loop iterates over each element. This is the canonical Bash idiom for array iteration. It correctly handles elements with whitespace, which is critical for robust scripting.

Answer

for (i=0; i<${#fruits[@]}; i++); do ... done

Answer

for fruit in ${fruits[*]}; do ... done

Answer

for fruit in $fruits; do ... done

Question 5

An administrator is investigating a Bash script that is failing unexpectedly. They want to see each command as it is executed to debug the script. Which command should be added to the script?

Accepted Answer

set -x. set -x enables shell tracing, which prints each command and its expanded arguments to stderr as the script executes, prefixed with '+'. This is the standard way to debug a Bash script by seeing exactly what commands run and with what values.

Answer

set -v

Answer

set -e

Answer

set -o xtrace

Question 6

A DevOps engineer is building a Docker image for a web application. They want to ensure the image is as small as possible and that sensitive data is not left in layers. Which two practices help achieve these goals? (Choose TWO.)

Accepted Answer

Using multi-stage builds to separate build and runtime environments.. Option B is correct because multi-stage builds let you compile or build the application in an intermediate stage and then copy only the required artifacts into a minimal final runtime image, which both shrinks the image and keeps build-time secrets and tooling out of the shipped layers. Option C is correct because chaining multiple RUN commands with && into a single RUN creates one layer, and any temporary files or sensitive data created and deleted within that same layer never persist in the final image, whereas separate RUN commands would leave them in earlier layers. Option A is not correct because ADD is a superset of COPY with extra behaviors like automatic tar extraction and remote URL fetching, which adds unnecessary risk and does not reduce image size. Option D is not correct because the latest tag is mutable and non-deterministic, which harms reproducibility and can pull in larger or vulnerable base images. Option E is not correct because installing all packages in a single layer does not by itself remove build caches or secrets, and it is not one of the two practices that specifically address image size and sensitive data.

Answer

Using the ADD instruction instead of COPY.

Answer

Using the latest tag for base images.

Answer

Installing all packages in a single layer.

Question 7

A Linux administrator wants to run a container that stops automatically after the main process exits. Which Docker run flag should be used?

Accepted Answer

--rm. The --rm flag tells Docker to automatically remove the container and its filesystem when the container exits. Since the main process has already terminated, the container stops and is cleaned up, which matches the requirement of stopping automatically after the main process exits. This is the standard way to run ephemeral, one-off containers without leaving stopped containers behind.

Answer

--stop-timeout

Answer

--restart=always

Answer

-d

Question 8

A system administrator is writing a Bash script that needs to iterate over a list of IP addresses stored in a file, one per line. Which loop construct should be used?

Accepted Answer

for i in $(cat ip_list.txt); do ... done. The construct 'for i in $(cat ip_list.txt)' uses command substitution to expand the file contents into a word list, which the for loop then iterates over one token at a time. Since the file contains one IP per line and IPs contain no whitespace, this correctly iterates each address. It is the idiomatic Bash pattern for looping over a simple line-delimited list.

Answer

for ((i=0; i<$(wc -l < ip_list.txt); i++)); do ... done

Answer

while read line; do ... done < ip_list.txt

Answer

until IFS= read -r line; do ... done < ip_list.txt

Question 9

A Linux administrator is writing a Bash script that must handle errors gracefully. Which TWO of the following techniques ensure the script exits on error and provides debugging information? (Select TWO.)

Accepted Answer

set -x. set -e makes the script exit on any command failure. set -x prints commands as they are executed, aiding debugging. Together they ensure error exit and debugging output.

Answer

set -u

Answer

trap 'echo error' ERR

Answer

set -o pipefail

Question 10

An administrator needs to deploy an application stack that includes a web server and a database. The containers must be able to communicate with each other and be easily managed together. Which TWO tools or methods can accomplish this? (Select TWO.)

Accepted Answer

Docker Compose. Docker Compose (B) is correct because it defines multi-container applications in a single YAML file, automatically creating a shared network so the web server and database containers can communicate by service name, and it manages the stack's lifecycle together with commands like docker compose up and down. Kubernetes (E) is correct because it orchestrates multi-container workloads using Pods, Services, and Deployments, providing built-in networking and DNS so the web and database containers can communicate while being managed as one application. Ansible with the docker_container module (A) can create containers but does not natively provide the coupled multi-container networking and lifecycle management this scenario requires. Podman pods (C) group containers sharing a network namespace, but the question targets tools for easily managing a web-plus-database stack together, which Compose and Kubernetes address more directly. Docker run with --link (D) is a legacy, deprecated feature that only enables one-way container discovery and does not provide orchestration or easy group management.

Answer

Ansible playbook with docker_container module

Answer

Podman pods

Answer

Docker run with --link

Question 11

A DevOps engineer is writing a Dockerfile for a Python web application. The base image is python:3.9-slim. The application code is in the current directory, and the container should expose port 8080. Which Dockerfile instructions correctly build the image and run the application using python app.py?

Accepted Answer

FROM python:3.9-slim
COPY . /app
WORKDIR /app
EXPOSE 8080
CMD ['python', 'app.py']. It uses the exec form of CMD (CMD ['python', 'app.py']), which directly executes the command without a shell, providing proper signal handling and is the recommended format. Option A uses shell form (CMD python app.py), which runs the command as a subprocess of /bin/sh and may not handle signals correctly, making it less ideal. Additionally, the Dockerfile must include WORKDIR to set the working directory and COPY to add code; all options have these but only B uses the correct CMD syntax.

Answer

FROM python:3.9-slim
COPY . /app
WORKDIR /app
EXPOSE 8080
CMD python app.py

Answer

FROM python:3.9-slim
COPY . /app
EXPOSE 8080
ENTRYPOINT python app.py

Answer

FROM python:3.9-slim
WORKDIR /app
COPY . .
EXPOSE 8080
RUN python app.py

Question 12

A system administrator is creating an Ansible playbook to deploy a web server on a group of hosts. The playbook needs to install the nginx package, start the service, and ensure it is enabled on boot. Which playbook structure is correct?

Accepted Answer

---
- hosts: webservers
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present
    - name: Start and enable nginx
      service:
        name: nginx
        state: started
        enabled: yes. Option A uses the correct Ansible module structure: the apt module installs nginx with state: present, and the service module starts and enables it with state: started and enabled: yes. This is the idiomatic, idempotent way to manage a Debian/Ubuntu web server with Ansible, and the YAML indentation and module parameters are valid.

Answer

---
- hosts: webservers
  tasks:
    - name: Install nginx
      apt:
        name: nginx
        state: present
    - name: Start and enable nginx
      systemd:
        name: nginx
        state: started
        enabled: yes

Answer

---
- hosts: webservers
  tasks:
    - name: Install nginx
      command: apt install -y nginx
    - name: Start nginx
      command: systemctl start nginx

Answer

---
- hosts: webservers
  tasks:
    - name: Install nginx
      yum:
        name: nginx
        state: present
    - name: Start and enable nginx
      service:
        name: nginx
        state: started
        enabled: yes

Question 13

In a Bash script, the following array is defined: fruits=('apple' 'banana' 'cherry'). Which syntax correctly iterates over all elements of the array?

Accepted Answer

for fruit in "${fruits[@]}"; do echo $fruit; done. To iterate over all elements of an array, use for fruit in "${fruits[@]}"; do ... done. The [@] syntax expands to all elements.

Answer

for fruit in "${fruits[*]}"; do echo $fruit; done

Answer

for fruit in ${fruits[@]}; do echo $fruit; done

Answer

for fruit in ${fruits}; do echo $fruit; done

Question 14

A Kubernetes administrator is creating a YAML manifest for a Deployment. Which three fields are required in a valid Deployment specification? (Choose three.)

Accepted Answer

apiVersion. A valid Kubernetes Deployment manifest actually requires four top-level fields: apiVersion, kind, metadata, and spec. The current explanation incorrectly states that only three fields are required and that metadata is not one of them. The correct required fields are all of A, B, C, and E.

Answer

status

Question 15

A developer creates a Dockerfile for a web application. Which instruction should be used to define the command that runs when the container starts, allowing the container to accept arguments from the docker run command?

Accepted Answer

CMD. CMD is the Dockerfile instruction that provides the default command executed when a container starts, and critically, it can be overridden by arguments passed on the 'docker run' command line. This makes it the right choice when the requirement is to allow runtime arguments to replace the default. ENTRYPOINT, by contrast, sets a fixed executable that is not easily overridden (only via --entrypoint).

Answer

START

Answer

ENTRYPOINT

Answer

RUN