EX294 Create content collections and execution environments Practice Test 3 — 15 Questions

Question 1

A DevOps team maintains an Ansible environment using execution environments. They have been using a local execution environment image named 'custom-ee:latest' built with ansible-builder. Recently, they updated the requirements.yml file to include a new collection from Automation Hub. They rebuilt the execution environment using ansible-builder and pushed it to their private registry as 'registry.internal/custom-ee:1.2'. However, when running ansible-navigator on a control node, it still uses the old local image and does not pull the updated one. The ansible-navigator configuration file (ansible-navigator.yml) specifies:

execution-environment: image: registry.internal/custom-ee:1.2

enabled: true

pull: policy: tag

The control node has no prior local image with that tag. What is the most likely reason the new image is not being used?

execution-environment:
  image: registry.internal/custom-ee:1.2
  enabled: true
  pull:
    policy: tag

The control node has no prior local image with that tag. What is the most likely reason the new image is not being used?

Accepted Answer

An environment variable such as ANSIBLE_NAVIGATOR_EXECUTION_ENVIRONMENT_IMAGE overrides the configuration file, pointing to the old image.. Environment variables take precedence over configuration file settings in ansible-navigator. If `ANSIBLE_NAVIGATOR_EXECUTION_ENVIRONMENT_IMAGE` is set to the old local image (e.g., `custom-ee:latest`), it overrides the `image` value in `ansible-navigator.yml`, causing the tool to ignore the updated registry image. This is a common misconfiguration when environment variables persist from previous sessions or CI/CD pipelines.

Answer

The control node does not have network access to the registry, so it cannot pull the image and falls back to the local 'latest' image.

Answer

The pull policy 'tag' only pulls if the local image tag differs from the registry tag, and since the local image is 'latest', it compares to '1.2' and pulls, but something else prevents it.

Answer

The image was rebuilt with a different tag than '1.2', so the registry does not have that tag.

Question 2

An automation engineer at a financial services company is creating an execution environment (EE) definition using ansible-builder. The EE must include the `community.general` collection from Ansible Galaxy and the `redhat.rhel_system_roles` collection from Red Hat Automation Hub. The engineer writes the following `execution-environment.yml`:

```yaml
version: 3

build_arg_defaults:
  ANSIBLE_GALAXY_CLI_COLLECTION_OPTS: '--pre'

dependencies:
  galaxy: requirements.yml
```

And the `requirements.yml` contains:

```yaml
collections:
  - name: community.general
  - name: redhat.rhel_system_roles
```

When building, the process fails because it cannot resolve `redhat.rhel_system_roles` from Galaxy. What is the most appropriate change to allow the build to succeed while keeping both collections?

Accepted Answer

Add both collections to `requirements.yml` and add an `ansible.cfg` file in the build context that defines `[galaxy]` with `server_list` including Automation Hub and Galaxy, and provide the Automation Hub API token via `ANSIBLE_GALAXY_SERVER_AUTOMATION_HUB_TOKEN` in `build_arg_defaults`.. To build an execution environment with collections from both Ansible Galaxy and Red Hat Automation Hub, you must configure ansible-galaxy to know about both sources. This is done by providing an ansible.cfg file in the build context that defines the galaxy server list, and supplying the Automation Hub token as a build argument. The requirements.yml then lists the collections, and ansible-builder will use the configured servers to resolve them.

Answer

Add `ansible_config: ansible.cfg` to the `execution-environment.yml` and configure `[galaxy]` server lists in `ansible.cfg` to point to Automation Hub for certified content.

Answer

Create a `requirements.yml` that includes both collections and add an `ansible.cfg` with `[galaxy]` server entries, then reference it in `execution-environment.yml` using `additional_build_files` and `ansible_config`.

Answer

Split the collections into two separate requirements files: one for Galaxy and one for Automation Hub, then reference both under `dependencies.galaxy` in `execution-environment.yml`.

Question 3

An automation engineer is creating an execution environment for a project that requires the `community.general` collection from Ansible Galaxy and the `redhat.rhel_system_roles` collection from Red Hat Automation Hub. The engineer wants both collections included during the build. Where should these collection requirements be declared so that `ansible-builder` includes them?

Accepted Answer

In the `requirements.yml` file referenced by the `collections` key in `execution-environment.yml`.. Execution environments use an `execution-environment.yml` file to define dependencies. The `collections` key points to a requirements file that lists collections to install. This file can include collections from multiple sources, such as Galaxy and Automation Hub. The other options either target the wrong file type or use incorrect syntax. Thus, referencing a requirements file is the correct approach.

Answer

In the `execution-environment.yml` file, directly under a `collections` list with each collection name and version.

Answer

In the `ansible.cfg` file under the `[galaxy]` section, using the `collections` option.

Answer

In the `bindep.txt` file, listing the collection names as system packages.

Question 4

You are using ansible-builder to create an execution environment. Your execution environment definition file (execution-environment.yml) specifies collections in the dependencies section, including a collection from a private Automation Hub that requires authentication. After building, the build fails with an error indicating that the collection could not be found. Which configuration should you add to enable ansible-builder to authenticate to the private Automation Hub?

Accepted Answer

Set the ANSIBLE_GALAXY_SERVER_LIST environment variable to include the private Automation Hub server and provide credentials via ANSIBLE_GALAXY_SERVER__TOKEN.. ansible-builder relies on ansible-galaxy to install collections, and ansible-galaxy supports multiple Galaxy servers via the ANSIBLE_GALAXY_SERVER_LIST environment variable. Each server can have its own token using ANSIBLE_GALAXY_SERVER__TOKEN. This approach keeps credentials out of the definition file and allows the build to authenticate to a private Automation Hub.

Answer

Add a galaxy_server section to the execution-environment.yml file with the URL and token of the private Automation Hub.

Answer

Embed the private Automation Hub credentials directly in the requirements.yml file used by ansible-builder to list collections.

Answer

Create an ansible.cfg file in the build context with a [galaxy] section containing server_list and api_key entries for the private Automation Hub.

Question 5

You are building an execution environment with ansible-builder for a project that must use the certified collection redhat.insights from Red Hat Automation Hub. The build host has no direct internet access but can reach an internal Automation Hub mirror at https://hub.internal.example.com/api/galaxy/. The execution-environment.yml already defines the base image and dependencies. Where must you configure the Galaxy server URL and token so ansible-builder can resolve the collection during the build?

Accepted Answer

In a custom ansible.cfg referenced by the ANSIBLE_GALAXY_SERVER_* environment variables or the builder's ansible_config option, placed where ansible-builder reads it.. ansible-builder performs collection resolution using an ansible.cfg that declares the Galaxy servers and their tokens. Pointing the builder at that configuration, or exporting ANSIBLE_GALAXY_SERVER_* variables, lets it authenticate to the internal Automation Hub mirror and download the certified collection. Other files such as execution-environment.yml or requirements.yml control dependencies but do not supply the server credentials the builder needs.

Answer

In the requirements.yml dependencies list using the source: https://hub.internal.example.com/api/galaxy/ and token: fields for each collection.

Answer

In execution-environment.yml under additional_build_files as a requirements file with the server URL and token.

Answer

In ansible.cfg under [galaxy_server.hub_internal] with url and token keys.

Question 6

An automation team is building an execution environment using `ansible-builder`. They need to install additional Python packages required by their custom modules. Which file should they modify to specify these Python dependencies?

Accepted Answer

`requirements.txt`. Execution environments require Python packages to support Ansible modules. The standard way to declare these is through a Python requirements file, typically `requirements.txt`, which is referenced in the `execution-environment.yml` under the `python` key. This file is processed by `pip` during the image build. Other files serve different purposes, such as system packages or collection metadata.

Answer

`galaxy.yml` inside the collection.

Answer

`execution-environment.yml` under the `dependencies` section with a `python` list.

Answer

`bindep.txt`

Question 7

An automation team is creating an execution environment to standardize their Ansible automation. They need to ensure the environment includes specific Ansible collections and Python packages. Which two files can be used to declare these dependencies for `ansible-builder`? (Choose two.)

Accepted Answer

requirements.yml. The `execution-environment.yml` file is the central definition for an execution environment, and it can directly list dependencies or reference other files like `requirements.yml` for collections. A `requirements.yml` file can be used to specify collections to install. Together, these files allow `ansible-builder` to construct the image with the required content. Other files like `galaxy.yml` or `ansible.cfg` serve different roles and are not used for declaring execution environment dependencies.

Answer

bindep.txt

Answer

galaxy.yml

Answer

ansible.cfg

Question 8

You are preparing an execution environment for a team that will run playbooks using collections from both Red Hat Automation Hub and a private Automation Hub. The build must be reproducible and must not rely on the public Galaxy server. Which two actions should you take to configure the execution environment build correctly? (Choose two.)

Accepted Answer

List the collections under dependencies.galaxy in execution-environment.yml, pointing to a requirements.yml that references the correct sources.. Correctly configuring the build requires telling ansible-builder which Galaxy servers to use and which collections to install. An ansible.cfg with both Automation Hub servers and their tokens supplies authentication, while dependencies.galaxy referencing a requirements file names the collections and their sources. Together these avoid the public Galaxy, keep credentials out of dependency files, and make the build reproducible.

Answer

Set ANSIBLE_GALAXY_IGNORE_CERTS to true so the build can reach both Automation Hub instances.

Answer

Add the private Automation Hub CA certificate to the base image and point the builder at that image.

Answer

Embed the private Automation Hub token directly in the requirements.yml file for each collection entry.

Question 9

A developer is preparing to publish a new version of a collection to a private Automation Hub. The collection has been built and is ready for distribution. Which two commands are valid for publishing the collection to Automation Hub? (Choose two.)

Accepted Answer

`ansible-galaxy collection publish acme-automation-1.0.0.tar.gz --api-key <token> --server automation_hub`. Publishing a collection to Automation Hub is done with the `ansible-galaxy collection publish` command. Authentication can be provided via `--api-key` or configured in `ansible.cfg` with a token. The `--server` option specifies the target Automation Hub. The other options are either invalid subcommands, deprecated, or use incorrect flags. Thus, the two valid commands are those using `publish` with appropriate authentication and server specification.

Answer

`ansible-galaxy collection upload acme-automation-1.0.0.tar.gz --server automation_hub`

Answer

`ansible-galaxy collection push acme-automation-1.0.0.tar.gz --server automation_hub`

Answer

`ansible-galaxy collection install acme-automation-1.0.0.tar.gz --publish`

Question 10

A developer is building an execution environment and needs to install a collection from a private Automation Hub that requires authentication. The developer has a token stored in an environment variable `ANSIBLE_HUB_TOKEN`. Which configuration in the `execution-environment.yml` file ensures `ansible-builder` can authenticate to the private Automation Hub during the build?

Accepted Answer

Create an `ansible.cfg` file in the build context with `[galaxy]` section containing `server_list` and `api_key`.. To authenticate to a private Automation Hub during an execution environment build, the most reliable method is to provide an `ansible.cfg` file in the build context. This file can contain a `[galaxy]` section with `server_list` and `api_key` settings. The `api_key` can reference the environment variable `ANSIBLE_HUB_TOKEN` if the environment variable is also passed to the build environment. This approach ensures `ansible-galaxy` uses the token when installing collections.

Answer

In the `execution-environment.yml`, set `galaxy_token: "{{ lookup('env', 'ANSIBLE_HUB_TOKEN') }}"` under `dependencies`.

Answer

Export the token as `ANSIBLE_GALAXY_TOKEN` before running `ansible-builder build`.

Answer

Under `dependencies`, add an `ansible_galaxy` key with `server` and `token` fields.

Question 11

A team builds an execution environment from a definition that includes `ansible.posix` and an internal collection hosted on a private Automation Hub. The build fails while resolving the internal collection because no Galaxy server credentials are available inside the container. Which mechanism allows the builder to authenticate to the private hub during the build?

Accepted Answer

Set the ANSIBLE_GALAXY_SERVER_<name>_TOKEN build argument and reference it in the definition.. Authenticating to a private Automation Hub during an execution environment build is done by passing Galaxy server credentials, including the token, through build arguments that the definition references. This injects the credential into the container environment so `ansible-galaxy` can resolve the internal collection, unlike file-based workarounds that do not carry authentication.

Answer

Add the internal collection tarball to the `collections` list with a `file://` URL.

Answer

Mount a pre-populated ansible.cfg via the definition's build steps and reference a token file.

Answer

Store the token in the `options` section under `galaxy_token`.

Question 12

An automation team is designing a content collection to distribute internal Ansible modules across the organization. The collection should be installed from a private Galaxy server. To minimize namespace conflicts and ensure discoverability, which naming convention should be used for the collection?

Accepted Answer

namespace.collection_name. In Ansible, collections are distributed using a fully qualified collection name (FQCN) in the format `namespace.collection_name`. This naming convention is required by the Ansible Galaxy server and the `ansible-galaxy collection install` command to uniquely identify and install collections, minimizing namespace conflicts and ensuring discoverability across the organization.

Answer

collection_name.namespace

Answer

namespace_collection_name

Answer

namespace-collection_name

Question 13

When building an execution environment with ansible-builder, a developer notices that the build process fails with an error about missing dependencies. The developer wants to ensure all required Python packages are installed in the execution environment. Which file should be used to specify additional Python packages?

Accepted Answer

requirements.txt. In Ansible Builder, the `requirements.txt` file is used to specify additional Python packages that should be installed in the execution environment. When building an execution environment, Ansible Builder reads this file and installs the listed packages via pip, ensuring all required Python dependencies are present.

Answer

meta/runtime.yml

Answer

galaxy.yml

Answer

bindep.txt

Question 14

A system administrator wants to publish a custom Ansible collection to a private Automation Hub. What is the correct command to build the collection before publishing?

Accepted Answer

ansible-galaxy collection build. `ansible-galaxy collection build` is the command that compiles the collection directory into a distributable tarball (e.g., `mycollection-1.0.0.tar.gz`), which is the required artifact for publishing to a private Automation Hub. Without this build step, there is no archive to upload.

Answer

ansible-galaxy collection init mycollection

Answer

ansible-galaxy collection publish ./mycollection-1.0.0.tar.gz

Answer

ansible-galaxy collection install .

Question 15

A DevOps engineer is creating an execution environment for a team that needs both Ansible and the 'requests' Python library. The engineer creates an execution environment definition file (EE.yml) with the following content:
---
version: 3
images:
  base_image:
    name: registry.redhat.io/ansible-automation-platform-22/ee-minimal-rhel8:latest
options:
  package_manager_path: /usr/bin/microdnf
dependencies:
  python: requirements.txt
  system: bindep.txt

What is missing from this definition to ensure the 'requests' library is installed?

Accepted Answer

The requirements.txt file must contain 'requests'.. The execution environment definition file (EE.yml) specifies dependencies via external files like requirements.txt for Python packages. To install the 'requests' library, the requirements.txt file must explicitly list 'requests' as a dependency. Without it, the build process will not include the library, regardless of other configuration options.

Answer

The package_manager_path should be /usr/bin/yum.

Answer

The galaxy.yml file must be added to the dependencies section.

Answer

The base image should be ee-supported-rhel8 instead.