DevOps Engineer Interview Questions and Answers for 2025

Canary Release is the practice of making staged releases in which software changes and update are rolled out to a small number of the users first, so that it can be tested and provide us with feedback. Once the approval is provided and the change is accepted, the update is rolled out to the rest of the users. 

With canaries, the new version of the application is gradually deployed to the server while getting a very small amount of live traffic (i.e., a subset of live users is connecting to the new version while the rest are still using the previous version). 

One of the most effective points of using Canary deployment is that we can push new features more frequently without having to worry that any new feature will harm the experience of our entire user base. 

In Linux, root privileges refer to a user account that has full access to all the files, application and the system functionalities. There are two ways we can reset the password: 

For resetting password as sudo user: 

We can follow below steps: 

Navigate to terminal in window and we can write below command 

 $ sudo passwd root 

System will prompt to enter the same password that we use for login to system. 

Next, we get prompt for the new password.  We need to enter the new password in prompt and also re-enter it on retype password prompt to verify the same. 

In case, we are resetting password as root user: 

We can login to terminal using below command: 

$ su root 

We will be asked to provide the password to which we need to enter current root password.  

Once entered as root user, we can type following command to change password  

$passwd  

In Linux, timestamp is actually stored in the form of number and not in date and time format. So, to make it human readable format Linux convert it into required format of date and time. 

Generally, timestamp is recorded for time when any action is performed on file. 

It helps to keep records of when a file was accessed, modified or added.  

mtime:- Stands for Modification time. It indicates the last time the content of file was modified. 

For example- if new data is added, deleted or edited, the modified timestamp changes  

To view the modified timestamp, we can use below command: 

$ ls - l <filename> 

ctime:- Stands for change time. It refers to the change in the file property and indicate last time when some Metadata of file was changed.  

Example- if permission of file were modified by user or by some automated code, ctime will show the same. 

To view the modified timestamp, we can use below command: 

$ ls - lc <filename> 

atime:- Stands for access time. It refers to timestamp when file' content is read by application or user using grep or cat command but did not necessary modify anything in file. 

To view the modified timestamp, we can use below command: 

$ ls - lu <filename> 

xargs in linux is used to build and execute command from the standard input. 

It takes the input and convert it into command argument for another command. 

There will be some commands in Linux that accepts the argument, this is where xargs came as rescue. This is mainly used in file management where xargs is used along with rm, cp commands. 

Syntax to use xargs in linux: 

xargs <option> [command] 

Few of most common used xargs options are: 

• 0: This will input items which are terminated by null character instead of white spaces 
• a file: This will read items from file instead of the standard input 
• delimiter = delim : It will input items that are terminated by a special character 
• p: prompt the user about whether to run each command line and read a line from terminal. 
• r: If the standard input does not contain any non-blanks, do not run the command 
• x: exit if the size is exceeded. 
• help: It will print the summary of the options to xargs and exit 
• version: This will print the version no. of xargs and exit 

To block the ip address in Linux, we need to use iptables and netfilter firewall along with login as root user. 

To block the IP Address, we can use the below command: 

iptables -A INPUT -s <IP-ADDRESS> -j DROP 

In case if we want to block the access to one port from an ip address to port n then we can below command: 

iptables -A INPUT -s <ip-address> -p tcp --destination-port n -j DROP 

The above rule will drop all packets coming from IP- address to port mail server port n. 

In case, we want to unblock these IP: 

 iptables -D INPUT -s xx.xxx.xx.xx -j DROP 
iptables -D INPUT -s <ip-address> -j DROP 
service iptables save 

We can refresh static component of deployed application using Weblogic. Deployer can be defined a specify component and target a server through the following syntax:

java weblogic.Deployer -adminurl http://admin:7001 -name appname -targets server1,server2 -deploy jsps/*.jsp 

Sanity testing is  basically the subset of the regression testing which is performed to ensure that code changes that  are made by the Development team are working on the system. The focus of the team during sanity testing process is to validate the functionality of the application and not in  detailed testing of each and every component.

We have pre commit in the Git provided by Git repository which is also known as hook,  basically  it gets triggered just  before the commit happens. We can write a script by making use of this hook to implement the smoke testing.

The script can be used to  perform the sanity checks on the changes that are newly added and   committed into the repository.

Below is the sample script which is checking if any .py files which are to be committed are properly formatted with the  use of the python formatting tool pyfmt (auto formatting source code tool in python). In case  the files are not properly formatted, then the script prevents the changes to be committed to the repository by exiting with status 1 

The NRPE stands for ‘Nagios Remote Plugin Executor’ .It is the Nagios agent that allows to execute  Nagios plugins remotely on the other Linux or Unix machines system monitoring using scripts. It helps in monitoring the remote machine metrics such as disk usage, CPU load etc. NRPE can communicate with a few of the Windows agent addons , which helps us to check the metrics of remote windows machines using these  windows agent addons.

Dogpile effect is  referred as  the event when cache expires, and websites are hit by the multiple requests made by the client at the same time. It is also  referred to as cache stampede which occur when computing system employs cache which leads to the high load.

One of the common way through which we can prevent dogpile effect is by implementing the semaphore locks in the cache. In this process  when the cache expires in the system, the first process  acquire the lock  and starts generating new value to the cache.

Trigger build remotely provides us with the flexibility which allows triggering a job from the various ways such as the script, command line, hooks at the time when someone has committed a code change or triggers a job . 

We can perform various Jenkins function programmatically using Jenkins Remote Access API .Such as :- 

• Retrieving information about jobs, views, nodes, builds, etc.  
• Trigger a build , stopping the build, enable/disable a Job, group/remove jobs into/from views, etc. 
• Create/copy/modify/delete jobs. 

 It can be triggered via CURL, WGET commands as below. We can also use Postman or GitHub webhook to trigger the job. - 

curl -X POST -u user:apitoken http://jenkins/job/yourorg/job/yourrepo/job/master/build 
$wget http://jenkins/job/yourorg/job/yourrepo/job/master/build 
$wget --auth-no-challenge --http-user=username --http-password=api_token http://jenkins/job/yourorg/job/yourrepo/job/master/build 

To track down the commit which introduce bug is generally a quite time consuming process, in case we are not sure about faulty commit. For same, we have Git bisect command, which works on principle of binary search. 

Git bisect start # starts the bisecting session 
Git bisect bad # marks the current revision as bad 
Git bisect good revision # marks the last known good revision 

On running these, Git will checkout a revision halfway between the known “good” and “bad” versions. Post which we can run specs again and mark good or bad accordingly. 

This process continues until we get the commit that introduced the bug. 

Both of these commands are designed to integrate changes from one branch into another branch, but they just do it in very different ways.  

Whenever in doubt, it is always recommended to use Git merge instead of Git rebase 

• Merge takes all the changes in one branch and merges them into another branch in one commit. 
• The resulting tree structure of the history (generally only noticeable when looking at a commit graph) is different (one will have branches, the other won't). 
• Merge and rebase will handle conflicts differently. Rebase will present conflicts one commit at a time where merge will present them all at once. 

Here is the quick comparison: 

Below are some of the factors that helps to decide when to use merge and rebase commands: 

• In case of open source or public repositories, it is recommended to use Git merge, since there could be many developer contributing toward branch. 

In the case of using Git rebase for above scenario, it will destroy the branch and result in broken repositories. To correct the same, we need to use Git pull --rebase. 

• Rebase can result in loss of committed work if not applied correctly. This is destructive operation which can lead to breaking consistency of other developer's contribution. 
• In any case ,when we need to work on any reverting a commit to previous commit, it become very difficult. In such cases merge operation comes handy. 

Backup and restoring Jenkins data is very much needed in case of disaster recovery, auditing and many more purpose, therefore having good backup and restore of Jenkins instance is critical and highly important for the application .

Other than this, few other factors where backup is required:

• Disaster recovery.
• Recovering an older configuration (an accidental configuration change may not be discovered for some time).
• Recovering a file that is corrupted or was deleted accidentally.

Files to back up:

$JENKINS_HOME: Backing up the entire $JENKINS_HOME directory preserves the entire Jenkins instance which include - build logs, job configs, plugins, configurations etc. To restore the system, just copy the entire backup to the new system.

In case taking back up only for the configuration file separately , we can check in the $JENKINS_HOME directory. ./config.xml where the main Jenkins configuration files are stored. Other configuration files also have the .xml suffix. Specify $JENKINS_HOME/*.xml to back up all configuration files.

Configuration files can also be stored in an SCM repository. This keeps copies of all previous versions of each file that can be retrieved using standard SCM facilities.

We have Jenkins Thin Backup plugin which is used to take back up in Jenkins. This helps to backs up of all the data based on the schedule that we mention and handles the backup retention as well.

We simply need to install the 'thin backup plugin' in Jenkins under the Manage section and enable from the setting tab along with the detail such as what to back up and the backup directory.

Restoring:

• Backup files are in the tar+zip format.
• We can Copy these to another server where it can be unzip and un-tar.

Docker works on client-server architecture, which includes three main components i.e. Docker client, Docker Host and Docker registry. 

The Docker client talks to Docker Daemon, which runs on the host operating system and listens for Docker API requests and manages the Docker objects such as images, containers, networks, and volumes. A daemon can also communicate with the other daemons to manage Docker services 

The Docker client and Daemon can run on the same system. The different types of Docker components in a Docker architecture are– 

Docker Client: This performs Docker build pull and run operations to establish communication with the Docker Host. This is the primary way where users interact with Docker. When we run the docker commands the client sends these commands to dockerd, which carries them out. Docker API is used by Docker commands. It is possible for Docker client to communicate with more than one daemon. 

Docker Host: This It contains the docker daemon, images, containers, networks, and storage. The images will be the kind of metadata for the applications which are containerized in the containers. The Docker Host is used to provide an environment to execute and run applications.

Docker Object: When we use Docker, we are creating and using images, containers, networks, volumes, plugins, and other objects. Below is the brief overview of some of those objects. 

1. Images: An image a read-only template which contain instructions for creating a docker container. It is used to store and ship applications. We can either ther create our own images or can only use the images that are created by others and published in a registry. To build own image, we need to create a Docker file by defining the steps needed to create the image and run it. Each instruction in a Docker file creates a layer in the image. When you change the Docker file and rebuild the image, only those layers which have changed are rebuilt. This is part of what makes images so lightweight, small, and fast, when compared to other virtualization technologies.
2. Container: A container is a runnable instance of an image. With the help of Docker API or CLI, we can start, stop, delete or move a container. We can connect a container to one or more networks, attach storage to it, or even create a new image based on its current state.
3. Networks : Docker networking provides complete isolation for docker containers. It requires very less Operating system instances to run the workload.

There are primarily 5 network drivers in docker: 

1. Bridge: It is the default network driver. We can use this when your application is running on standalone containers i.e. different containers communicate with the same docker host. 
2. Host: This driver removes the network isolation between docker containers and docker host. When we don’t need any isolation between the container and host then it is used. 
3. Overlay: For communication with each other, it will enable the swarm services. 
4. None: It disables all networking. 
5. macvlan: This driver assigns mac(Media Access control) address to containers to make them look like physical devices. It routes the traffic between containers through their mac addresses.  
6. Storage: We can store data within the writable layer of the container but it requires a storage driver. Storage driver controls and manages the images and containers on our docker host. 

With respect to persistent storage, Docker offers four options:- 

1. Data Volumes 
2. Volume Container 
3. Directory Mounts 
4. Storage Plugins 

Docker Registry: All the Docker images are stored in docker registry. The public registries which is also known as  Docker Hub or Docker Cloud is accessible for everyone and  can be used by anyone. 

We have the privilege to run our private Registry as well, by using Docker pull and Docker run command , which will pull the required image from private configured registry. 

Reference: https://docs.docker.com/get-started/overview/ 

The "Error response from daemon: Timeout was reached before node joined." failure happens when the ‘manager’ docker machine is not active due to which  the new node machine will not be able to join the swarm cluster. 

To fix this: 

Step 1: Check for the active machine hosts as: 

$ docker-machine active 

Step 2: Activate the ‘manager’ machine as: 

$ eval $(docker-machine env manager) 
$ docker-machine active 

Step 3: Get the swarm join token as worker 

$docker swarm join-token worker 

Step 4: Connect to the worker machine say: worker1  

$docker-machine ssh worker1 

Step 5: Now while running the swarm join token command, it should be successful. 

Handlers are special Task that get executed only when triggered or called by a notifier in another Task. 

The difference between handlers and regular Task is that handlers run only when notified using notify directive. And executed generally at end of file after all Task are completed.

It is generally used in the playbook where configuration changes are need to be  implemented due to which   restart, start ,reload and stop services needs to be implemented. 

Example for Ansible Handlers- Taking a scenerio, when we want to restart the Apache HTTP server after configuring virtual host using Ansible playbook . In this case , we first need to specify two Task in playbook- one Task is to configure the virtual host file and other Task will be to  restart Apache. 

But here  the challenge is Apache service will be restarted with each successive playbook run irrespective of anything changed on configuration file. 

That is because there is  Task that explicitly restart Apache and doesn't take into account about the state of Apache service. Also, restarting the Apache service on each run  is not desirable ,because it can lead to resource overhead.  

Here handlers came into picture and  can be used as rescue.  

We can write playbook consist of regular Task and a handler. The regular Task install the Apache http server on target system. Once installed, notifier  notifies all the handlers Task which start the Apache server. 

Also, like we discuss earlier, regular Task will be executed prior to handler. 

Now, in this case if playbook is executed again, the handler Task will not run because state and configuration remain unchanged for  Apache service .Therefore can prevent unnecessary Apache restart. 

Yes we can use JSON instead of YAML . 

To run docker compose with JSON, below can be used: 

docker-compose -f docker-compose.json up 

This error occur when we are trying to add a node that already using the node in our Docker swarm earlier. So if we want to add the node in another swarm, then we need to leave from the earlier swarm by using the command:

$ docker swarm leave --force 
Node left the swarm. 

RAM in computer are actively used to store data and program. And required at time of running the program. 

Other than this we have second type of memory in Linux system, i.e. Swap Space  

Swap Space in Linux is used to provide /substitute the disk Space to RAM when it gets filled up and system require more space to run program and store data. 

Swap Space in Linux is used when RAM get full, but can't be considered as replacement for more RAM. Example - if we have data storing excel that is running and as of now, no extra space required. But as time proceed when data grows, and multiple other application running that could lead to fill up of RAM.  

Here swap Space came as rescue which can help the application keep running. 

Types of Swap Memory: - 

Swap Space can be dedicated swap partition, swap file, combination of swap partition and swap files. 

Swap Partition: This is the by default swap memory, similar to hard drive dedicated to system. 

Swap File- A swap file system creates temporary file storage in case there is no sufficient amount of space left in hard drive to create Swap partition. It swaps the section of RAM storage from idle program and frees up the memory for other process 

With the help of same, more memory can be used by computer than earlier physically present. 

Amount of system RAM Recommended for Swap space:- 

2GB or less RAM , Swap should be  twice the RAM 

RAM between 2GB to 8GB, swap pace should be  Same as RAM 

RAM between 8GB to 64GB, swap Space should be  0.5 times the RAM 

For RAM more than 64GB ,swap space is workload dependent. 

Creating the swap space and enable in Linux: 

• Login as super user.

su 
password: root-password

• We need to create a file in a selected directory to add swap space by typing:

dd if=/dev/zero of=/<dir> /<myswapfile> bs=1024 count=<number_blocks_needed> 

where <dir>  is a directory in which you have permission to add swap space. The myswapfile is the name of the swap file you are creating. The number_blocks_needed is an amount of 1024-byte blocks you want to create 

• Verify the file was created by typing:

ls -l /dir/myswapfile 

• Initialize the new swap area by typing:

mkswap /dir/myswapfile 

• Run the swapon command to enable the new swap space for paging and swapping by typing the following:

swapon -a /dir/myswapfile 

• Verify that the extra swap space was added by typing: 

swapon -s 

The output shows the allocated swap space. 

To achieve the order of execution, we can use "depend_on" which needs to be added in docker-compose.yml file.

Example:

version: "2.4" 
services: 
 backend: 
build: . 
depends_on: 
- db 
 db: 
image: postgres 

Addition of the service dependencies has various causes and effects. In this example, docker-compose up command starts DB container before backend and run as mentioned in service dependency