701-100 LPI DevOps Tools Engineer Free Practice Exam Questions (2025 Updated)

In Docker, if you reference an image without specifying a tag, Docker assumes the tag to be latest. The latest tag is used as the default tag for the most recent stable version of the image.

References:

Docker Documentation - Images

A. Microservices architecture allows different services to be developed, deployed, and replaced independently, facilitating the replacement of specific functionalities without impacting the entire system.

D. Due to the network latency and overhead associated with inter-service communication, interaction between microservices can indeed be slower than the interaction of components within a monolithic application.

E. One of the significant advantages of microservices is the ability to update and redeploy individual services independently, which helps in faster iteration and deployment cycles.

References:

Microservices Architecture

Microservices vs Monolithic Architecture

The correct answer to the question "What has to be done in order to submit the log data of the new application to Logstash?" is:

C. Add the log file to the path option within the log prospector in the Filebeat configuration and restart Filebeat.

To configure Filebeat to submit log data from a new application log file, you need to update the Filebeat configuration to include the path to the new log file and then restart Filebeat.

C. Add the log file to the path option within the log prospector in the Filebeat configuration and restart Filebeat: This involves editing the Filebeat configuration file to include the new log file path under the input section and then restarting the Filebeat service to apply the changes.

The other options are incorrect:

A: Logstash configuration should not be directly modified for this purpose; it is handled by Filebeat.

B: Logrotate is not involved in Filebeat's log shipping process.

D: There is no need to create a cron job for this purpose.

E: Using symbolic links to /dev/filebeat is not a standard or recommended approach.

References:

Filebeat Documentation - Configuration

Docker automatically assigns names to containers using a combination of an adjective and a famous scientist's or hacker's name (e.g., clever_ritchie). This naming convention is used to make container names more human-readable and memorable.

References: Docker Documentation - Container Naming

C. When performing a canary deployment, the database schema needs to be compatible with both the new version and the old version of the service to ensure smooth operation and rollback if necessary.

A. Modifying the database schema, especially in a large and complex database, can be time-consuming and may negatively impact performance due to the migration processes and locks required during the schema change.

References:

Canary Deployments

Database Schema Changes

In Ansible, the copy module is used to copy files from the local system to a remote system. The correct syntax to copy example.txt to /tmp/example.txt on the managed system is:

src: example.txt

dest: /tmp/example.txt

Explanation of the other options:

rsync: Ansible does not have an rsync module with the syntax provided.

retrieve: This is not a valid Ansible module.

cp: This is not a valid Ansible module.

transfer: This is not a valid Ansible module.

References:

Ansible Documentation - copy module

When a Docker container is started and the Dockerfile contains both COPY and VOLUME instructions as follows:

COPY data/ /data/

VOLUME /data

C. Existing files from /data/ in the image are copied to the new volume: Docker will copy the contents of /data in the image into the volume when the container is started. This ensures that the initial state of the volume includes the files that were copied into /data during the build process.

E. A new volume is created and mounted to /data/ within the new container: Docker creates a new volume if none is specified and mounts it to /data in the container. This volume persists data outside the container's lifecycle.

The other options are incorrect:

A: Files in /data/ in the image are made available in the running container via the volume.

B: Changes to files within /data/ do not affect the Docker image; they only affect the volume.

D: Docker does not raise an error when mounting a volume to a directory that already contains data.

References:

Docker Documentation - Managing Data in Containers

Ansible provides several modules to manipulate the contents of files. The correct modules for changing the contents of a file are:

lineinfile: This module ensures a particular line is present or absent in a file, or it can replace existing lines that match a pattern.

replace: This module performs a search and replace on a string in a file.

patch: This module applies a patch to a file. It can be used to apply diffs to files, which essentially modifies the contents based on the diff provided.

The other options, insert and modify, are not standard Ansible modules for file content manipulation.

References:

Ansible Documentation - lineinfile module

Ansible Documentation - replace module

Ansible Documentation - patch module

Agile software development methodologies prioritize flexibility and adaptability over strict adherence to plans. They encourage self-organizing teams and flexible processes to quickly respond to change and deliver value incrementally.

Self-organization: Teams are empowered to organize their work and make decisions collaboratively without heavy-handed management.

Flexibility: Agile methodologies advocate for adapting processes and plans as necessary to meet the needs of the project and stakeholders.

References:

Agile Manifesto

Principles behind the Agile Manifesto

Service discovery is crucial in container environments to enable containers to find and communicate with each other. The common mechanisms for service discovery in container platforms include:

Environment Variables: Container platforms often set environment variables within containers to provide information about services. This method is simple and allows containers to access necessary details without additional configuration.

DNS Records: Many container platforms maintain DNS records that map service names to container IP addresses. This allows services to be discovered and accessed using standard DNS queries, which is a scalable and widely used approach.

The other options are not standard methods for service discovery:

A: There is no docker service discover command for service discovery.

C: Listing localhost ports in /etc/services is not a typical method used by container platforms.

D: Mounting sockets for all services into containers’ file systems is not a common practice for service discovery.

References:

Docker Documentation - Service Discovery

Kubernetes Documentation - Service Discovery

In Kubernetes, a Deployment manages ReplicaSets and ensures that the specified number of replicas for a given Pod is always maintained. If a Pod managed by a ReplicaSet is terminated (e.g., using the command kubectl delete pod ), the ReplicaSet detects the discrepancy in the desired state (number of replicas) and the actual state. As a result, the ReplicaSet will immediately create a new Pod to replace the terminated one and maintain the desired number of replicas.

Deployment Management: A Kubernetes Deployment is responsible for maintaining the desired state of Pods through ReplicaSets.

ReplicaSet Functionality: A ReplicaSet ensures that a specified number of Pod replicas are running at all times.

Pod Termination: When a Pod is terminated, the ReplicaSet notices the reduction in the number of running Pods.

Replacement Pod Creation: To restore the desired state, the ReplicaSet automatically creates a new Pod to replace the terminated one.

References:

Kubernetes Documentation - Deployments

Kubernetes Documentation - ReplicaSet

Test-Driven Development (TDD) is a software development process where tests are written before the code that needs to pass the tests is implemented. The principal concept behind TDD is to write a test for a new function or method, see it fail, then write the minimum amount of code required to make the test pass, and finally refactor the code while keeping the tests green.

Write a Test: Before writing code, a developer writes a test for the desired function or method.

Run the Test: The new test should fail initially because the function or method hasn't been implemented yet.

Write Code: Implement the minimum code necessary to pass the test.

Run Tests: Run all tests to ensure the new code passes and doesn't break any existing functionality.

Refactor: Clean up the code while ensuring all tests continue to pass.

References:

Test-Driven Development (TDD)

For containers to communicate across different Docker nodes, they need to be part of a network that supports multi-host networking. The bridge network driver is limited to a single host.

C. Start the containers on the same node: If both containers are started on the same Docker node, they can communicate using the bridged network.

E. Use an overlay network instead of a bridged network: Overlay networks are designed for multi-host communication and allow containers on different Docker nodes to communicate with each other.

The other options are incorrect:

A: Using a host network removes network isolation but does not help with multi-host container communication.

B: There is no --inter-container option for the docker network create command.

D: --network=isolated_nw,nofence is not a valid parameter for Docker network settings.

References:

Docker Documentation - Networking overview

Docker Documentation - Overlay networks

B. Jenkins supports a master-slave architecture where the master node distributes build tasks to multiple slave nodes, thereby improving performance and enabling load balancing.

D. Jenkins is highly extensible through plugins. Its functionality can be significantly enhanced by installing various plugins that support different tools, languages, and activities such as building, deploying, and automating tasks.

References:

Jenkins Distributed Builds

Jenkins Plugins

In Puppet, the equivalent of an Ansible Playbook is called a Manifest. Manifests are files containing Puppet code that define the desired state of a system. These manifests use the .pp file extension and are written in the Puppet language.

Puppet Manifest: This is the correct term for a file that contains the desired configuration state for managed nodes in Puppet.

The other options do not accurately represent the concept:

Puppet Catalog: This is a compiled version of the manifest, containing all the resources and their dependencies.

Puppet Playbook, Puppet Factsheet, and Puppet Declaration are not terms used to describe the configuration files in Puppet.

References:

Puppet Documentation - Manifests

In Ansible, the become keyword is used to control privilege escalation. This allows a user to execute tasks with different privileges, such as running tasks as the root user. When become is set to yes, Ansible will use the configured method (such as sudo, su, or others) to elevate privileges.

become: This directive allows users to control privilege escalation for the tasks they are running. When set to yes, it enables the use of privilege escalation.

priv_user, elevate, super, and sudo are not valid Ansible inventory configuration options for controlling privilege escalation.

References:

Ansible Documentation - Privilege Escalation

Reference https://www.packer.io/docs/commands/validate.html

The packer validate template.json command checks the specified Packer template file for syntax correctness and completeness. This command ensures that the template is properly structured and ready to be used for building images.

Syntax Check: Verifies the JSON syntax of the template.

Completeness Check: Ensures all required fields and configurations are present in the template.

References:

Packer Documentation - validate