DEV Community: Ayush Gupta

Docker - Basics

Ayush Gupta — Sun, 05 Oct 2025 14:38:51 +0000

Need for Docker ?

Suppose a development team is working on a project and creating an application, now suppose the application is build using different technologies.

for example - React, Java, Oracle DB

Now suppose developers are also using different operating system when creating the application

for example - Windows, Linux, Mac OS

Now in order to install the technologies like React, Java, Oracle DB in different operating systems, the process may be different.

for example -

Installation steps, installation paths, configurations, and versions of technologies, everything may be different

Now this creates a problem, suppose application is working our system and we are using windows, and now we provide the same code to other developer who is using Mac OS, and now when they tried to run the same code, in their system, it is not working for them.

Now we have a problem -

So in order to solve this problem, we will use Docker

Now let's try to understand what is Docker ?

Docker-

So as of now we are running the application in our operating system only, for example - Windows or Mac OS

Now when we use Docker, we will run the application inside a Docker Container.

Docker Containers -

Now in order to run the application inside a Docker Container, we will not be directly putting the Application code, and the required technologies on which this application is built upon in the Docker containers.

Docker Image-

Instead, we will first create a Docker image — which is like a blueprint containing everything we need to run the application (code, libraries, dependencies, configurations, etc.)

Then, using this Docker image, Docker will create a container — which is a running instance of that image.

Docker Image → Blueprint
Docker Container → Running instance of that blueprint

Now let's consider one scenario, is it possible one Docker Container, can have more then one Docker image ?

DevOps - Basics

Ayush Gupta — Sun, 21 Sep 2025 19:23:18 +0000

Hi Everyone,

Let's try to understand DevOps

Suppose we are not using DevOps ?

Before DevOps-

Let's consider we have 2 teams, a development team and an operations team, now suppose the development team has created an application, now in order to run this application we need some infrastructure like servers, database, but this infrastructure is not setup yet, and now the question is who is going to create and setup this infrastructure ? is it going to be our development team only, or do we need to take help from any other team ?

so in order to solve this problem, we will take help from operations team, who is going to create and setup the infrastructure.

Now there is a roadblock, operation team will have to wait for development team to create the application first.

But you must be thinking where are the developers creating this application, I mean since their is no infrastructure has been setup yet right ?

so the developers are creating the application in there local system only as of now.

So once the application is working fine in their local environment, they’ll reach out to the operations team and request the necessary infrastructure.

Let's suppose we started with a testing environment

for example - two servers and one database.

After the testing environment is ready, the developers can deploy their application there.

This allows all the developers to test and run the application together in a shared setup.

The only problem is operation team has to wait for the development team to create the application first.

Now, suppose we also need a Production Environment as well.

In this case, the operations team will again have to wait — not only for the development team to complete the application, but also for the QA team to finish their testing successfully in the testing environment.

Now this is one approach, here setting up of the infrastructure is done manually only.

Now let's see an another way of working which will help us in solving the above problem of doing things manually, which is DevOps.

DevOps-

In DevOps, we use Infrastructure as Code and CI/CD pipelines.

Infrastructure as Code -

It means we are writing code and creating scripts or config files to set up and manage servers, networks, databases, and environments instead of doing it manually.

Let's try to understand this using below examples -

Suppose we don't use Infrastructure as Code ?

In this case an operations engineer has to create servers, setup infrastructure manually.

Now suppose we will use Infrastructure as Code ?

Here we will write code as scripts (in YAML, JSON, or a tool’s language like Terraform or Ansible) that describes the infrastructure.

and now when we run a command or execute our script, then our infrastructure is created and configured automatically.

CI/CD pipelines -

As of now we have the infrastructure only, but our application is not deployed yet, so to deploy the application in a particular environment like a Testing or a Production environment, we will use CI/CD pipelines.

Now let's try to understand the CI/CD pipelines ?

so as of now in the case of infrastructure as code, we are creating and setting up infrastructure using scripts only and not doing anything manually and similarly in order to deploy an application in that infrastructure, we will use scripts only or we can say we will build CI/CD Pipelines which will deploy our application automatically in the infrastructure.

CI - Continuous Integration

suppose we have created an application, for now let's consider the code of this application exist in our local system only.

Now let's suppose we have pushed the code to our remote repository or Github.

now comes CI, It will be build the code and runs test cases, these test cases are part of the code itself.

CD -

In CD, we are trying to deploy the code in a particular environment like Testing or Production etc.

now in order to deploy the code or we can say build, we will use two strategies -

1. Continuous Delivery
2. Continuous Deployment

now let's try to understand both of them

1. Continuous Delivery -

In Continuous Delivery, we will deploy the code in a Testing environment only, then QA team will check how the app is working, before we deploy the same app in the production environment.

Now in this case of Continuous Delivery, the deployment to a production environment will be done manually only.

2. Continuous Deployment -

In Continuous Delivery, Everything is done automatically, first to Testing environment and then to production as well.

Bash Scripting - Basics

Ayush Gupta — Sat, 13 Sep 2025 20:07:03 +0000

Hi Everyone,

Lets try to work with the Bash Scripting now.

In the previous post we have created only a .sh file and mention the shebang statement as #!/bin/bash which tells us that we are using Bash shell.

Lets try to use the features which Bash Shell may provide to us.

lets create a .sh file once and give it a name hello.sh

but you may be thinking how do we create this .sh file ?

we can use a text editor which is a part of Linix

for example - vi text editor

in our terminal we can type -

vi hello.sh

now vi text editor will be open for us, but we will not be able to add anything as of now, first we need to go into the insert mode, by pressing "i" button in your keyboard, after that it will show us that we are in insert mode and now we can start editing the hello.sh file

as discussed in previous post, first we need to add the shebang statement to tell what shell we are using

#!/bin/bash

Lets create a simple script, that will print "Hello World" when we execute it

#!/bin/bash

echo "Hello World"

as of now we have added above 2 lines , one is shebang statement and second is echo "Hello World"

but we have a roadblock, before executing the hello.sh file, we need to save this hello.sh file and come out from the text editor right ?

in order to do that, we need to do following -

press escape -> press shift + :wq -> press enter

here w - write or save the file, and q - quit

now we are out from the vi text editor

lets see how to run or execute our script now, and regarding this we need to follow the following way of executing the script

./hello.sh

but it may still not work, due to permissions

so we need to change the permissions first using following

chmod +x hello.sh

here we are just giving executable permission to our hello.sh file to user, group and others, means everyone can execute our hello.sh file or script

now lets follow same -

./hello.sh

we will get -

Hello World

Terminal vs Shell vs Bash vs Bash Scripting

Ayush Gupta — Sat, 13 Sep 2025 19:52:25 +0000

Hi Everyone,

Let's try to understand some useful concepts in Linux OS

we will start with the terminal

Terminal -

we can consider, a terminal is a place or a GUI interface, where we can type our commands, and when we hit enter, we can see the output of the commands.

Now let's see, what happens when we hit enter after typing a command ?

you may be thinking, either the command will work and give us the desired output or it will fail and give us the error ?

but who is actually executing these commands ? and after execution how the output of the command is actually showing in the terminal window ?

In simple terms the commands are actually executing by the kernel

but its not like when we type a command in the terminal and hit enter and that command will reach kernel and kernel is able to execute it.

Shell -

It is actually the shell who is taking the commands from terminal and sending it the kernel for execution, and once command is executed, Kernel is going to send the output back to the shell and now shell is going to show it to the terminal.

Terminal -> Shell -> Kernel

Now let's consider a scenario, what if a command doesn't exist or there is a syntax error in our command, so in this case will the Shell, still going to send the command to the Kernel ?

so in the above scenario the shell is going to search first, and if the command doesn't exist, it will not send the command to kernel for execution, and we will simply get error as following -

bash: command_name: command not found

Bash-

Now there are other types of Shells also, who are just reading the commands from Terminal and sending it to the Kernel for execution.

and the most common Shell is Bash

Bash Scripting -

So as of now we are typing the commands one at a time and when we hit enter, Shell is reading the command from terminal and sending to Kernel for execution right ?

now let's consider an example -

suppose you have 10 commands to follow to install some package in a server and you have to follow all the commands in a sequence, one way is to do it manually, which means we are going to type a command and hit enter, and once it is completed, we have to type the second command and hit enter .. continue

so as you can see in above scenario, we are typing each command manually, and then waiting for it also before completing and typing the next command and finally our package is installed in the server.

But now we have a roadblock, suppose we have 5 servers also, and in all the 5 servers, we have to install the same package, so shall we follow the same steps again and again in all the 5 servers ?

To solve this problem, we will be using Bash Scripting

Let's see how to create a script ?

we need put all the 10 commands which we were following manually in a file as following -

hello.sh

here "hello" is the name of the file, ".sh" is the file extension

#!/bin/bash

echo "Hello World"

Now let's consider we have put all the 10 commands in out hello.sh file, now all we need to do is, is to run or execute this file using following way -

./hello.sh

Now Shell will read this file line by line, and start sending the commands we have written in each line to the kernel for execution, until it has done reading all the lines of the file.

Now as you can see, we are not evening typing the commands in terminal also, we have just put all the commands in a file, Shell itself, is doing all the work automatically, now to solve the problem of installing the same package in all the 5 server, all we need to do is run the same script in all the 5 servers, that's all.

so using Bash Scripting we are able to automate the process of installing our packages in our servers.