Docker Commands Cheat Sheet

Container Lifecycle

• Creating and Starting a Container

  • docker run -d --name my_container nginx- Use this command to create and start a container named my_container using the nginx image.

• Starting, Stopping, and Restarting Containers

  • docker stop my_container - Stops the specified container.

  • docker start my_container - Starts a previously stopped container.

  • docker restart my_container - Restarts a container.

• Listing Containers

  • docker ps - Lists all currently running containers.

  • docker ps -a - Lists all containers, including those that are stopped.

Image Management

• Fetching an Image from a Registry

  • docker pull ubuntu- Retrieves the ubuntu image from the Docker Hub or other specified registry.

• Building an Image from a Dockerfile

  • docker build -t my_image .- Builds an image named my_image from a Dockerfile in the current directory.

• Listing and Removing Images

  • docker images - Lists all local Docker images.

  • docker rmi my_image - Removes the specified image from the local system.

Container Operations

• Interacting with Containers

  • docker exec -it my_container bash - Executes a command (bash in this case) inside a running container.

  • docker attach my_container - Attaches to a running container for interaction.

  • docker logs my_container - Displays logs from the specified container.

• Managing Container Resources

  • docker cp file.txt my_container:/path/to/destination - Copies files between a container and the host system.

  • docker pause my_container and docker unpause my_container - Pauses or unpauses a running container.

  • docker inspect my_container - Displays detailed information about a specific container.

Networking

• Network Management

  • docker network ls - Lists all networks available on the Docker host.

  • docker network create my_network - Creates a new network.

  • docker network connect my_network my_container and docker network disconnect my_network my_container - Connects or disconnects a container from a network.

Volume Management

• Volume Commands

  • docker volume ls - Lists all Docker volumes.

  • docker volume create my_volume - Creates a new volume named my_volume.

  • docker volume rm my_volume - Removes the specified volume.

  • docker volume inspect my_volume - Provides detailed information about a specific volume.

Follow Rohit Ghumare for more such an amazing content.

Check DevOpscommunity.in for more FREE resources.

📝Table of Contents:

1. Introduction to Log Analytics

2. Understanding AWS Native Services

3. Setting up AWS CloudWatch Logs

4. Configuring AWS CloudTrail for Log Collection

5. Analyzing Logs with Amazon Athena

6. Creating Real-time Dashboards with Amazon CloudWatch Logs Insights

7. Building Custom Log Monitoring Solutions with Amazon Kinesis Data Firehose

8. Implementing Log Analysis with Amazon Elasticsearch Service

9. Utilizing AWS Glue for Log Data ETL Processes

10. Applying Machine Learning to Log Analytics with Amazon SageMaker

11. Securing Log Data with AWS Identity and Access Management

12. Integrating Log Analytics with AWS Lambda

13. Scaling Log Analytics with Amazon Redshift

14. Monitoring and Alerting Strategies for Log Analytics

15. Best Practices for Real-time AWS Log Analytics

📝 Motivation:

"Things work well when understood well".

Personally projects are half a mile properly dealt with source code alone. To assist a document answering the queries like why, what, how is the key.

📝 Introduction:

➡️ Welcome to the fascinating world of "Real Time AWS Log Analytics: Harnessing Native Services"! This project guides you through one of the most important indemand task of log analytics and guides with the usage of AWS native services for performing real-time log analytics.

➡️ In today's data-driven landscape, organizations generate massive volumes of log data from various sources such as applications, servers, network devices, and security systems. The ability to analyze this data in real time is crucial for detecting anomalies, identifying security threats, and gaining valuable insights to optimize operations.

➡️ The Documentation provided (Github Wiki) will strongly assist thorughout the project will detailed statements and workflows. Inside, you'll discover a roadmap to leverage AWS native services to build scalable and efficient log analytics solutions. We'll take you step-by-step through each chapter, providing clear explanations, practical examples, and best practices to ensure you gain a deep understanding of the concepts and techniques.

➡️ But this is not your typical technical guide. We've crafted this to be human-friendly and engaging, making your learning experience enjoyable. Along the way, you'll find vibrant visuals, helpful diagrams, and even some fun emojis to keep you motivated and excited about the possibilities.

➡️ So, whether you're sipping your favorite coffee or curling up in a cozy corner, get ready to dive into the exciting world of real-time log analytics using AWS native services. Unleash the power of your log data, uncover hidden insights, and pave the way for your organization's success. Remember, the sky's the limit when it comes to harnessing the potential of AWS log analytics! ➡️ So, whether you're sipping your favorite coffee or curling up in a cozy corner, get ready to dive into the exciting world of real-time log analytics using AWS native services. Unleash the power of your log data, uncover hidden insights, and pave the way for your organization's success. Remember, the sky's the limit when it comes to harnessing the potential of AWS log analytics!

Let's begin this incredible journey together! 🚀

What are we going to learn from this Project?

• Set up Jenkins on AWS EC2 instance.

• Create a security group for Jenkins.

• Connect to Jenkins instance using EC2 security groups

• Install Jenkins on the EC2 instance

• Creating a Dockerfile

• Manage some Jenkins plugins and learn about Webhooks works

• Create a job for automating CI/CD deployment

• How to integrate Jenkins and GitHub

Here's the Workflow for our Project ⬇️

Github Repo: Repository

Note: Before getting started with the Project you need to have an AWS Tier account and for setting up your AWS account if you are using it for the first time, you can check out this video

So let's get started

Set up Jenkins on AWS EC2 instance

Let start by creating an EC2 instance and running Jenkins on it

• Search for EC2 in the Search bar on the top and click on it

  

• Now let's launch an instance by clicking on 'Launch instances'

  

• Now, enter some details for your instance, name it 'Jenkins-master'

• I am opting for Ubuntu Server(free tier) here.

• Make sure that the selected server you are opting for, lies in the free tier

• Choose the size of the instance "t2.micro" or anything that lies in the free tier.

  

• And now Let's create a key pair for your instance, name it aws-jenkins choose ".pem", if you are going to use SSH to connect to your instance, or ".ppk" if you are using putty & download it and now launch the instance.

  

• And Wait for the Status Check to complete (Running)

  

Now it is time to Connect of instance(Server)

• Click on “Connect” and select the "EC2 instance connect” option.

  

  

  • Congratulations, you have now connected to the instance

    

Install Jenkins on your Instance

• We are using sudo it as a prefix with every command, you can also do sudo -su this in the beginning to avoid that.

• Enter the command, for a quick update of all the software packages on your instance

• Update your system

    sudo apt update
  

• Install java

    sudo apt install openjdk-11-jre
  

• Validate installation

    java -version
  

• It should look something like this

    openjdk version "11.0.12" 2021-07-20 OpenJDK Runtime Environment (build 11.0.12+7-post-Debian-2) OpenJDK 64-Bit Server VM (build 11.0.12+7-post-Debian-2, mixed mode, sharing)
  

• Install Jenkins

  Just copy these commands and paste them onto your terminal.

    curl -fsSL https://pkg.jenkins.io/debian/jenkins.io.key | sudo tee \   /usr/share/keyrings/jenkins-keyring.asc > /dev/null
  

    echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \   https://pkg.jenkins.io/debian binary/ | sudo tee \   /etc/apt/sources.list.d/jenkins.list > /dev/null
  

    sudo apt-get update
  

    sudo apt-get install jenkins
  

• Start Jenkins

    sudo systemctl enable jenkins
  

    sudo systemctl start jenkins
  

    sudo systemctl status jenkins
  

  

• Now copy the public IP address of the Jenkins instance, which is present in the details of the instance

• Enter this IP address with the port number, i.e., "<ip_address:port_number>"- "18.182.13.97:8080"

  

  

  • Now, get the password by entering the following command and enter it in the text box

        sudo cat /var/lib/jenkins/secrets/initialAdminPassword
    

  • Click on install the suggested plugins

    

  • Go ahead and enter your username and stuff as asked

  • You are ready to use Jenkins🎉

Creating a Container

• After running Jenkins on our host now is time to create a Dockerfile to create a Dockerfile we need to install it first docker in our instance.

    sudo apt install docker.io
    sudo usermod -a -G docker $USER
  

    FROM node:12.2.0-alpine
    WORKDIR app
    COPY . .
    RUN npm install
    EXPOSE 8000
    CMD ["node","app.js"]
  

• Now its time to make docker image and container out of the docker file

    sudo docker build . -t node-app
  
    sudo docker run -d -p 8000:8000 todo-node-app
  

• To see our Project running we need to add port in our security group of the instance

• Follow the same steps, as followed in adding an inbound port for Jenkins, with some minor changes.

• One inbound rule need to be added

  

• Now copy the public IP address of the Jenkins master instance, which is present in the details of the instance

• Enter this IP address with the port number, i.e., "<ip_address:port_number>" - "18.182.13.97:8000"

  

• Here you have finally deployed your node project using AWS now ⬇️

Automating CI/CD using Jenkins

• First, you need to create a New Jenkins freestyle Pipeline

  

• After creating a Job we need to create a private and public key which will be used to integrate our GitHub and Jenkins for the Continuous Integration part.

• Going back to our instance to create public and private key we need to follow up the following commands.

ssh-keygen
cd .ssh
ls

sudo cat id_rsa.pub

Where id_rsa.pub stands for Public Key and id_rsa stands for Private Key

sudo cat id_rsa

• After generating the Public and Private Key now we need to connect our Jenkins with Github for that we need to create an SSH KEY.

• Go the Github Settings > click on SSH and GPG keys > Give any title and paste the Public Key we generated > click on Add SSH Key

  

• Now let's go back to Jenkins after creating the freestyle Project now we need to add the respective credentials

  

• Give the Jenkins Project a Description after that add the Repo url "Github Link"

  

• In the Source Code Management, choose git and enter the repository URL, by clicking on code.

  

• Create a new credential by clicking on add and new pop-up screen will appear overhere Select kind to be "SSH Username with private key", let the scope be global.

  

• Further, add the Private Key generate in the instance and paste it over here and click on add button to save it.

  

• After select the ubuntu credentials and Since all the code is in the master branch in the given project, we will use the master branch.

  

  

• Here click on the "Github hook trigger for GITScm polling" tick is so the any chance made in the Github code base can be reflect over here and a new build can be executed for that we need to make a small change in our Project Repository and all this work is done by Github Webhook > Go to Project Repo Settings > Webhook > Add webhook

• Over their you need to enter your this IP address with the port number, i.e., "<ip_address:port_number/github-webhook/>"- "http://54.250.242.79:8080/github-webhook/" and select content type as "application/json" and click on "Add webhook"

  

• Then let's go back to Jenkins Pipeline to work on the continuous deployment part for creating our docker image.

• Now Let build steps to create our Docker container

• Select Execute Shell and all the following CMD

    docker build . -t node-app-todo
    docker run -d -p 8000:8000 node-app-todo
  

  

• Now save and click on “Build Now”

  

  

• Yay! 🚀 that's a SUCCESS!

  

That's all for now. If you have any questions, please leave them in the comments section and I will do my best to answer them. Thanks for reading. Any feedbacks are welcome!! :). Connect with me on Twitter. Follow me for more such blogs on Hashnode.

Follow DevOps Community on Hashnode and Github

1. Open Source: Linux is an open-source operating system, which means that its source code is freely available to anyone who wants to use it, modify it or distribute it. This allows developers to customize and improve the operating system according to their specific needs, making Linux highly adaptable and flexible.

2. Stability and Reliability: Linux is known for its stability and reliability, which makes it a popular choice for servers and other mission-critical systems. The operating system is designed to be highly efficient and robust, with the ability to handle large workloads and provide uninterrupted service.

3. Security: Linux is known for its strong security features, which make it less vulnerable to viruses and malware than other operating systems. This is due to its built-in security features, such as the ability to set permissions and restrict access to files and directories.

4. Compatibility: Linux is highly compatible with a wide range of hardware and software, making it an ideal choice for developers who need to work with multiple platforms. This is because Linux supports a variety of programming languages and interfaces, making it easy to integrate with other systems.

5. Customizability: Linux is highly customizable, allowing developers to modify and tailor the operating system to their specific needs. This means that Linux can be customized for a wide range of applications, from desktop computers to servers and embedded systems. This level of customizability also makes Linux an ideal choice for developers who want to create their custom distributions or applications.

Linux Kernel:

Before we dig into Kernel and its use, let's dig into why we need a kernel.

Why do we need Kernel in an OS?

We need a kernel in an operating system because it provides an interface between software and hardware. Without a kernel, the software would not be able to access hardware resources such as memory, input/output devices, and network devices. The kernel also provides important system services such as process management, memory management, and security features. The kernel is the foundation upon which the rest of the operating system is built, and it is essential for the proper functioning of the system.

Introduction to Linux Kernel

The Linux Kernel is the core component of the Linux operating system. It is responsible for managing system resources and providing an interface for software to interact with hardware. The kernel is the first program that is loaded into memory when the system starts up, and it remains in memory for the entire time the system is running.

The kernel is designed to be highly configurable and customizable, allowing system administrators to tailor the system to their specific needs. It is also highly modular, allowing new functionality to be added to the system without requiring major modifications to the core kernel code.

Linux Kernel Versions

The Linux Kernel has gone through numerous revisions and updates since its initial release in 1991 by Linus Torvalds. Each version of the kernel is given a version number that consists of three parts: the major version number, the minor version number, and the patch level.

For example, the current stable version of the Linux Kernel as of February 2023 is 5.16.8, where 5 is the major version number, 16 is the minor version number, and 8 is the patch level.

The role of the Linux Kernel is to manage system resources and provide a layer of abstraction between software applications and the hardware. The kernel is responsible for many major tasks, including:

• Process and memory management: The kernel manages processes and allocates memory to them. It also controls the virtual memory system, which allows processes to use more memory than is physically available. Also determines where the CPU is being used and for how much time.

• Input/output management: The kernel provides an interface for software to interact with hardware devices, including input/output devices such as keyboards, mice, and printers.

• Network stack and device drivers: The kernel includes a network stack that provides networking functionality and device drivers that allow the software to communicate with hardware devices.

• File system management: The kernel manages the file system, including access control and security.

• Security and access control: The kernel provides access control and security features to protect the system and its data.

Linux Kernel Commands

Here are some commonly used Linux Kernel commands:

• uname -r: This command shows the kernel version of the running system.

• ls /lib/modules: This command lists the installed kernel modules.

• lsmod: This command lists the currently loaded kernel modules.

• modprobe: This command loads or unloads a kernel module.

• dmesg: This command displays the system message buffer, which contains information about the kernel and system events.

• sysctl: This command is used to modify and view kernel parameters at runtime.

Linux Boot Process and Run-levels:

The boot process of Linux can be broken down into several stages, each with its own tasks and responsibilities. These stages include:

1. BIOS POST

2. Boot Loader

3. Kernel Initialization

4. INIT Process

Let's explore each of these stages in detail.

1. BIOS POST

When you turn on a computer, the first thing that happens is a Power-On Self-Test (POST) performed by the Basic Input/Output System (BIOS). The POST checks the computer's hardware to make sure it is functioning properly, including the processor, memory, and input/output devices.

If the POST detects any issues, it will display an error message and prevent the computer from booting. If there are no issues, the BIOS will search for a bootable device, such as a hard drive or USB drive, and begin the boot process.

2. Boot Loader

The boot loader is responsible for loading the operating system kernel into memory. The most common boot loader for Linux is GRUB (GRand Unified Bootloader). When the BIOS hands over control to the boot loader, the boot loader displays a menu that allows the user to select which operating system they want to boot into.

The boot loader reads the kernel from the selected boot device and loads it into memory. The boot loader may also load an initial ramdisk (initrd), which is a temporary file system that contains essential files needed to boot the system, such as device drivers.

3. Kernel Initialization

Once the kernel has been loaded into memory, it begins the initialization process. The kernel first initializes the processor and memory management system. It then initializes the device drivers needed to access the hardware, such as the network card and storage devices.

The kernel also sets up the virtual file system and mounts the root file system. The root file system is the file system that contains the operating system and all its files.

4. INIT Process

The INIT process is the first user-space process that is started by the kernel. It is responsible for starting all the other user-space processes and services. The INIT process is identified by process ID 1 and is responsible for starting the system's run level.

The run-level determines which services and daemons should be started at boot time. The INIT process reads the configuration file (/etc/inittab) to determine which run-level to start. Each run-level has its own set of scripts that are executed to start the necessary services.

Once all the necessary services have been started, the system is ready to be used.

In conclusion, the Linux boot process involves several stages, each with its own responsibilities. The BIOS POST checks the hardware, the boot loader loads the kernel into memory, the kernel initializes the hardware and mounts the file system, and the INIT process starts the necessary user-space processes and services. Understanding the boot process can be helpful when troubleshooting boot-related issues.

In Linux, run-levels are a way to define the state in which the system should operate. Each run-level has a specific set of services that are started or stopped, which makes it possible to control what runs when the system is started up or shut down. The term run-levels is used in the SysV init systems. These have been replaced by systemd targets in systemd based systems.

The complete list of run-level and the corresponding systemd targets can be seen below:

• Runlevel 0: Halt or shut down the system.

• Runlevel 1: Single-user mode, which is used for system maintenance tasks.

• Runlevel 2: Multi-user mode without network services.

• Runlevel 3: Multi-user mode with network services.

• Runlevel 4: Not used by default, but can be configured for a specific purpose.

• Runlevel 5: Multi-user mode with a graphical user interface.

• Runlevel 6: Reboot the system.

Linux Basic commands and their uses :

Linux command types are divided into two parts.

• Internal commands

• External commands

  

Absolute and Relative Path :

→ ls-al: Lists files and directories with detailed information like permissions,size, owner, etc.

→ ls: Lists all files and directories in the present working directory

→ ls-R: Lists files in sub-directories as well

→ ls-a: Lists hidden files as well

→ ls -alh: All the inofrmation of file and hidden files with the human redable format 

→ cp (source) (destination): To copy a file 

→ cp -r (source) (destination) : To copy a directry to another directory with all the contents inside the directory 

→ cp (source) (destination) with the namme of file or dir you want:

→ cd or cd ~: Navigate to HOME directory

→ cd ..: Move one level up

→ cd: To change to a particular directory

→ cd /: Move to the root directory

→ cat > filename: Creates a new file

→ cat filename: Displays the file content

→ cat file1 file2 > file3: Joins two files (file1, file2) and stores the output in a new file (file3)

→ mv file "new file path": Moves the files to the new location

→ mv filename new_file_name: Renames the file to a new filename

→ sudo: Allows regular users to run programs with the security privileges of the superuser or root

→ rm filename: Deletes a file

→ rm -r: To delete directory with its files

→ man: Gives help information on a command

→ mkdir directory_name: Creates a new directory in the present working directory or an at the specified path

→ rmdir: Deletes a directory

→ mv: Renames a directory

Shell Types :

• Bourne Shell (sh)

• C Shell (csh or tcsh)

• Korn Shell (Ksh)

• Z Shell (zsh)

• Bourne again shell (bash)

Note: 
**sockets*cores*thres=CPUs
eg: 1*4*2= 8 Parallels threads can run at a time

File Types in Linux:

1. Regular : Images, Scripts, configuration / Data files

2. Directory : /home/bob /root /home/bob/code-directory

3. Special File :

       1. Character Files 
   
       2. Block Files   
   
       3. Links        -     Hard Link & Soft Link 
   
       4. Socket Files 
   
       5. Named Pipes
   

Let's explain each special file type :

1. Character Devices: Character devices are used for accessing hardware devices that are treated as a stream of characters, such as a keyboard, mouse, or serial port. These devices are accessed using input/output system calls, such as read() and write(). In the file system, character devices are represented by special files that reside in the /dev directory and have the prefix "c". For example, the file /dev/tty is a character device file that represents the current terminal.

2. Block Devices: Block devices are used for accessing hardware devices that are treated as a sequence of fixed-size blocks, such as hard drives and USB drives. These devices are accessed using input/output system calls, such as read() and write(). In the file system, block devices are represented by special files that reside in the /dev directory and have the prefix "b". For example, the file /dev/sda is a block device file that represents the first hard disk.

3. Named Pipes: Named pipes are used for inter-process communication between processes on the same system. They provide a way for processes to send and receive data using standard input/output system calls. In the file system, named pipes are represented by special files that reside in the /dev directory and have the prefix "p". For example, the file /dev/fifo is a named pipe file.

4. Sockets: Sockets are used for network communication between processes on different systems. They provide a way for processes to send and receive data over a network using standard input/output system calls. In the file system, sockets are represented by special files that reside in the /dev directory and have the prefix "s". For example, the file /dev/log is a socket file used by the system logging daemon.

5. Symbolic Links: Symbolic links, also known as soft links, are special files that point to another file or directory in the file system. They provide a way to create shortcuts to files and directories, and can be used to make file system navigation easier. In the file system, symbolic links are represented by special files that contain the path to the target file or directory. For example, the file /usr/local/bin/python is a symbolic link that points to the actual Python executable file.

We can identify the type of file with the command ls -ld and the first letter will show the type of file.

Below is the list of file types:

File system Hierarchy :

The Linux File System Hierarchy Standard (FSH) defines the organization of directories and files in a Linux-based operating system. The following is an overview of the key directories and their uses:

1. / : This is the root directory of the file system hierarchy, which contains all other directories and files. It is the first directory that is accessed when the system boots up.

2. /bin : This directory contains essential command-line utilities that are necessary for booting and repairing the system, such as ls, cp, and mv.

3. /boot : This directory contains the files needed to boot the system, including the kernel and boot loader files.

4. /dev : This directory contains device files for all the hardware devices connected to the system, such as hard drives, USB drives, and printers.

5. /etc : This directory contains configuration files for the system and its applications, such as network configuration, user authentication, and system startup scripts.

6. /home : This directory contains the home directories for all the system users, where they can store their personal files and data.

7. /lib : This directory contains the shared libraries that are needed by the system and its applications.

8. /media : This directory contains the mount points for removable media, such as USB drives and CDs.

9. /mnt : This directory contains the mount points for file systems that are mounted temporarily, such as network file systems.

10. /opt : This directory is used for installing third-party applications that are not part of the core system.

11. /proc : This directory contains virtual files that provide information about the system and its processes, such as system memory, CPU usage, and running processes.

12. /root : This directory is the home directory for the root user.

13. /run : This directory contains files that are created at runtime, such as process IDs and socket files.

14. /sbin : This directory contains essential system administration utilities, such as mount and shutdown.

15. /srv : This directory is used for storing data for services provided by the system, such as web server data or FTP server data.

16. /tmp : This directory is used for temporary file storage.

17. /usr : This directory contains user applications and their data, such as libraries, documentation, and binaries.

18. /var : This directory contains files that are expected to change in size or content over time, such as system logs, mail spools, and cached files.

Understanding the Linux File System Hierarchy and their uses is essential for managing a Linux-based operating system. It helps to locate files, diagnose problems, and make sure that the system is functioning correctly.

Package Management:

In Linux, a package is a compressed archive file that contains all the files necessary to install and run an application or software library. Packages are used to simplify the process of installing and managing software on a Linux system. They typically include the application or library files, as well as any configuration files, documentation, and dependencies required by the software. Package management tools such as apt, yum, and pacman are used to download, install, and manage packages on a Linux system.

We have to always take care of Linux Package managers dependencies and their own dependencies.

Functions of Package Managers:

1. Package Integrity and Authenticity

2. Simplified Package Management

3. Grouping Packages

4. Manage Dependencies

RPM and Debian based Linux Distributions, I have listed only three , there are many more.

RPM-based distributions:

1. Red Hat Enterprise Linux (RHEL) - RHEL is a commercial Linux distribution known for its stability and security. It is widely used in enterprise environments.

2. Fedora - Fedora is a community-driven distribution sponsored by Red Hat. It is known for its cutting-edge features and frequent updates.

3. CentOS - CentOS is a free and open-source distribution that is based on RHEL. It is commonly used for web servers, databases, and other enterprise applications.

Debian-based distributions:

1. Debian - Debian is a community-driven distribution known for its stability and adherence to the Unix philosophy. It is widely used in server environments.

2. Ubuntu - Ubuntu is a popular distribution that is based on Debian. It is known for its ease of use and strong community support.

3. Linux Mint - Linux Mint is a distribution that is based on Ubuntu. It is designed to be easy to use and includes many multimedia codecs and proprietary drivers.

Common Package Managers:

• DPKG: For Debian based distributions

• APT: A newer frontend for DPKG system found in base distribution like Ubuntu, Linux Mint.

• APT-GET: Traditions frontend system found in DPKG system.

• RPM: Base package manager for RedHat based distribution, such RedHat Enterprise Linux, Cent-OS, Fedora.

• YUM: A frontend for RPM system, found in RedHat based distribution.

• DNF: A more feature rich front-end for RPM system.

Working with RPM:

• Installation : Below command is used for installation of package.

[~]$ rpm -ivh telnet.rpm

where i stands for installation and v stands for verbose, it is used to print the detailed output of command.

• Uninstalling: Below command is used for uninstallation of packages.

[~]$ rpm -e telnet.rpm

• Upgrade: Below command upgrades a package to a newer version.

[~]$ rpm -Uvh telnet.rpm

• Query: To query and details about the installed package.

[~]$ rpm -q telnet.rpm

• Verifying: With below commands we can verify if the package is installed from trusted and secure source.

[~]$ rpm -Vf <path to file>

RPM is a package manager used in RedHat-based Linux distributions, such as RedHat Enterprise Linux, CentOS, and Fedora. RPM stands for "Red Hat Package Manager" and is used to download, install, and manage packages on a Linux system.

Here are some RPM commands that you can use to work with packages:

• rpm -qa: This command lists all the packages that are installed on the system.

• rpm -qf <filename>: This command tells you which package a file belongs to.

• rpm -qi <package>: This command displays information about a package, such as its version, release, and description.

• rpm -ql <package>: This command lists all the files that are included in a package.

• rpm -qR <package>: This command lists the dependencies required by a package.

• rpm -e <package>: This command removes a package from the system.

• rpm -U <package>: This command upgrades a package to a newer version.

• rpm -ivh <filename>: This command installs a package from a file.

When working with RPM packages, it is important to keep in mind the dependencies required by the package. RPM will automatically resolve and install any required dependencies, but it is important to ensure that all dependencies are met before installing a package.

In addition to RPM, there are other package managers available for managing packages on Linux systems, such as dpkg and APT for Debian-based distributions.

YUM

YUM (Yellowdog Updater, Modified) is a package manager used in Red Hat-based Linux distributions, such as Red Hat Enterprise Linux, CentOS, and Fedora. YUM is similar to the RPM package manager, but it provides additional features such as automatic dependency resolution and the ability to manage software repositories.

YUM can be used to install, update, and remove packages on a Linux system. It is also used to manage software repositories, which are collections of software packages that are available for installation on the system.

Here are some YUM commands that you can use to work with packages:

• yum install <package>: This command installs a package on the system.

• yum update <package>: This command updates a package to a newer version.

• yum remove <package>: This command removes a package from the system.

• yum search <package>: This command searches for a package in the available software repositories.

• yum list <package>: This command lists all the available versions of a package in the software repositories.

• yum info <package>: This command displays information about a package, such as its version, release, and description.

• yum clean all: This command clears the cached data used by YUM.

• yum repolist : This command will show all the repo’s added to the system.

• sudo yum provides tcpdump: This command will show the name of the package.

YUM also provides additional features such as the ability to manage software groups, which are collections of related packages, and the ability to manage software repositories and their associated GPG keys.

YUM is a powerful package manager that can simplify the process of installing and managing software on a Linux system. However, it is important to keep in mind the dependencies required by the packages being installed or updated, as well as the security implications of adding new software repositories to the system.

Package installation through YUM:

YUM (Yellowdog Updater, Modified) is a package manager that is used to install, update, and remove packages on Red Hat-based Linux distributions, such as Red Hat Enterprise Linux, CentOS, and Fedora. When installing a package with YUM, the package manager will first check to see if the package is available in the configured software repositories. If the package is available, YUM will download the package and any required dependencies from the repository and install them on the system.

Before downloading and installing the package, YUM will perform a dependency check to ensure that all required dependencies are met. If any dependencies are missing, YUM will prompt the user to install them before continuing with the package installation.

YUM also provides the ability to manage software groups, which are collections of related packages, and software repositories, which are collections of software packages that are available for installation on the system. When working with YUM, it is important to keep in mind the dependencies required by the packages being installed or updated, as well as the security implications of adding new software repositories to the system.

To install a package using YUM, follow these steps:

1. Update the package list by running sudo yum update.

2. Search for the package by running sudo yum search <package-name>.

3. Install the package by running sudo yum install <package-name>.

4. If the package has any dependencies, YUM will prompt you to confirm the installation of those dependencies. Type 'y' to confirm and proceed with the installation.

5. Once the package and its dependencies have been installed, YUM will display a message indicating that the installation was successful.

It is important to note that YUM requires root privileges to install packages. Therefore, you must prefix all YUM commands with 'sudo'.

DPKG: Debian Package Manager:

DPKG (Debian Package) is a package manager used in Debian-based Linux distributions, such as Debian, Ubuntu, and their derivatives. It is a low-level tool for handling software packages in a Debian system, and it is used to install, remove, and manage packages on a Debian-based system.

DPKG is a command-line tool that works in conjunction with other package management tools, such as APT (Advanced Package Tool), which is a higher-level package management tool. APT is a front-end to DPKG and provides a user-friendly interface to install, remove, and manage packages.

DPKG is responsible for handling the installation and removal of individual packages on a Debian-based system. It keeps track of installed packages, their dependencies, and their configuration files. It also provides tools for querying package information, including the version number, description, and dependencies of a package.

It is a low level package manager, similar to RPM it is used for below purpose. Package extension is .deb

• Installation/Upgrade: dpkg -i <package_file_name>

• Uninstalling: dpkg -r <package_file_name>

• List with version details: dpkg -l <package_file_name>

• status: dpkg -s <package_file_name>

• Verifying : dpkg -p <package_file_name>

APT/APT-GET :

APT (Advanced Package Tool) is a high-level package management system used in Debian-based Linux distributions, such as Debian, Ubuntu, and their derivatives. APT is a front-end to the lower-level package manager DPKG (Debian Package), and it provides a user-friendly interface for installing, updating, and removing packages on a Debian-based system.

APT uses a package database to keep track of installed packages and their dependencies, and it can automatically resolve dependencies and download packages from software repositories over the internet.

Commands:

• apt update: To refresh the repository , this command is used to get the package information from all available sources.

• apt upgrade: To upgrade all the available packages .

• apt edit-sources : To edit specific package and upgrade it

• apt search < file_name> : To search a file

• apt install: To install a package

• apt remove: To remove the package

• apt List : To list all the available packages

APT has several command-line tools, with the most commonly used tool being APT-GET. Here are some useful APT commands:

1. sudo apt-get update: This command updates the package list from all enabled repositories. It should be run before attempting to install or update packages to ensure that the package information is up-to-date.

2. sudo apt-get upgrade: This command upgrades all installed packages to their latest versions. It downloads and installs updated packages and their dependencies.

3. sudo apt-get install package_name: This command installs a package on the system. It automatically resolves dependencies and downloads any required packages from the configured repositories.

4. sudo apt-get remove package_name: This command removes a package from the system. It removes the package and any files associated with it, but it does not remove any dependencies that are no longer needed.

5. sudo apt-get autoremove: This command removes packages that were installed as dependencies but are no longer needed by any other packages on the system.

6. sudo apt-get purge package_name: This command removes a package from the system, including any configuration files associated with it.

7. sudo apt-get clean: This command cleans the local repository of retrieved package files that are no longer needed.

8. sudo apt-get autoclean: This command removes packages that are no longer available in the repositories and their associated files.

9. apt-cache search search_term: This command searches the package database for packages that match the search term.

10. apt-cache show package_name: This command shows information about a specific package, including its version number, description, and dependencies.

11. apt-cache policy package_name: This command shows the installed and available versions of a package, as well as the repository it is installed from.

To view file sizes in Linux, you can use the following commands:

• ls -lh: Lists files in the current directory with sizes in human-readable format.

• du -h <directory>: Shows the disk usage of files in a directory, with sizes in human-readable format.

• du -sh <directory>: Shows the total disk usage of a directory, with size in human-readable format.

• df -h: Displays the disk space usage of all mounted file systems, with sizes in human-readable format.

• du -sk : shows the file or directory in KB

Archiving files, Compressing and Uncompressing files.

Here are some Linux commands for archiving files, compressing and uncompressing files.

• tar: Tar is a command-line utility used for archiving files and directories into a single file, called a tarball. Tar can also be used to extract files from a tarball. The basic syntax for creating a tarball is:

tar -cvf archive.tar file1 file2 directory/
tar -cf test.tar file1 file2 file3 
ls -ltr test.tar
tar -tf test.tar : to see the contents of tarball
tar -xf test.tar : Extract the content from tarball 
tar -zcf test.tar file1 file2 file3 : To reduce the size

The -c option tells tar to create a new archive, the -v option enables verbose output, and the -f option specifies the name of the archive file. The files and directories to be included in the archive are listed at the end of the command.

To extract files from a tarball, use the following command:

tar -xvf archive.tar

The -x option tells tar to extract files from an archive.

• gzip: Gzip is a command-line utility used for compressing files. Gzip compresses files using the Lempel-Ziv algorithm, and can reduce file size by up to 90%. The basic syntax for compressing a file with gzip is:

gzip file.txt

This will create a compressed file called file.txt.gz.

To extract a compressed file, use the following command:

gzip -d file.txt.gz

The -d option tells gzip to decompress the file.

• zip: Zip is a command-line utility used for archiving files and directories into a single compressed file. Zip is similar to tar, but uses a different compression algorithm. The basic syntax for creating a zip file is:

zip archive.zip file1 file2 directory/

The files and directories to be included in the archive are listed at the end of the command.

To extract files from a zip file, use the following command:

unzip archive.zip

• bzip2: Bzip2 is a command-line utility used for compressing files. Bzip2 uses the Burrows-Wheeler transform algorithm, and can provide better compression than gzip. The basic syntax for compressing a file with bzip2 is:

bzip2 file.txt

This will create a compressed file called file.txt.bz2.

To extract a compressed file, use the following command:

bzip2 -d file.txt.bz2

The -d option tells bzip2 to decompress the file.

• x**z:**The xz command in Linux is used for file compression and decompression. It uses the LZMA algorithm to compress files, which can result in higher compression ratios than other compression algorithms such as gzip and bzip2. The basic syntax for compressing a file with xz is:

xz file.txt

This will create a compressed file called file.txt.xz.

To extract a compressed file, use the following command:

xz -d file.txt.xz

The -d option tells xz to decompress the file.

As per the standards, there is no need to uncompress the compressed files every-time. Below tools allows us to read the files without uncompressing them based on the type of file.

1. zcat

2. bzcat

3. xzcat

zcat hostfile.text.bz2

Searching for Files and Directories in Linux File system.

Here are some commands for searching for files and directories in the Linux file system:

• find: Find is a powerful command-line utility used to search for files and directories in a file system. The basic syntax for finding files is:

find /path/to/search -name "filename"

This will search for files with the name "filename" in the directory /path/to/search and its subdirectories. You can also use wildcards to search for files with names that match a pattern, such as:

find /path/to/search -name "*.txt"

This will search for all files with the extension ".txt" in the directory /path/to/search and its subdirectories.

• locate: Locate is another command-line utility used to search for files and directories in a file system. It is faster than the find command, but it relies on a pre-built index of the file system, so it may not be as up-to-date as the find command. To get the latest output we have to run the below command before locate command. The basic syntax for using locate is:

updatedb : It will update the database of FS.
locate filename

P.S: We have to run the update commands as root user.

This will search for files with the name "filename" in the entire file system. You can also use wildcards to search for files with names that match a pattern, such as:

locate *.txt

This will search for all files with the extension ".txt" in the entire file system.

• grep: Grep is a command-line utility used to search for text within files. The basic syntax for using grep is:

• The -i flag in grep is used to perform case-insensitive searches. This means that the search term will match both uppercase and lowercase versions of the letters in the search term. For example, the command grep -i "example" file.txt will match both "example" and "EXAMPLE" in the file file.txt.

• The -r flag in grep is used to perform a recursive search through directories. This means that grep will search through all files in the specified directory and its subdirectories. For example, the command grep -r "example" /path/to/directory will search for the string "example" in all files in the directory /path/to/directory and its subdirectories.

• v: This option tells grep to invert the match, meaning that it will only display lines that do not match the search term. For example, the command grep -v "example" file.txt will display all lines in file.txt that do not contain the word "example".

• w: This option tells grep to match only whole words. For example, the command grep -w "example" file.txt will only match lines that contain the word "example" as a whole word, and not as part of another word such as "examples".

• i: This option tells grep to perform a case-insensitive search. This means that the search term will match both uppercase and lowercase versions of the letters in the search term. For example, the command grep -i "example" file.txt will match both "example" and "EXAMPLE" in the file file.txt.

• A: This option tells grep to display n lines of context after the match. For example, the command grep -A 2 "example" file.txt will display the line containing the match as well as the two lines that follow it.

• B: This option tells grep to display n lines of context before the match. For example, the command grep -B 2 "example" file.txt will display the line containing the match as well as the two lines that come before it.

grep "search term" /path/to/file

This will search for the string "search term" in the file /path/to/file. You can also use wildcards to search for text within multiple files, such as:

grep "search term" /path/to/directory/*

This will search for the string "search term" in all files in the directory /path/to/directory.

• which: Which is a command-line utility used to locate the binary file of a command. The basic syntax for using which is:

which command

This will display the location of the binary file for the specified command.

• whereis: Whereis is a command-line utility used to locate the binary, source, and manual page files for a command. The basic syntax for using whereis is:

whereis command

This will display the location of the binary, source, and manual page files for the specified command.

IO Redirection:

Input/output (IO) redirection is a powerful feature of the Linux command line that allows you to redirect the input or output of a command to a file or another command. This can be useful for a variety of tasks, such as logging command output to a file, processing the output of a command in another command, or reading input from a file instead of the terminal.

Here are some common IO redirection operators in Linux:

• >: This operator redirects the output of a command to a file, overwriting the existing contents of the file. For example, the command ls > file.txt will write the output of the ls command to the file file.txt. If the file does not exist, it will be created. If the file already exists, its contents will be overwritten.

• >>: This operator redirects the output of a command to a file, appending the output to the end of the file. For example, the command ls >> file.txt will append the output of the ls command to the end of the file file.txt. If the file does not exist, it will be created.

• <: This operator redirects the input of a command from a file, instead of the terminal. For example, the command sort < file.txt will sort the contents of the file file.txt, using the file as input instead of the terminal.

• |: This operator redirects the output of one command to the input of another command. For example, the command ls | grep .txt will list all files in the current directory and pipe the output to the grep command, which will filter the output to show only files with the extension .txt.

Here are some examples of using IO redirection in Linux:

• ls > file.txt: This command writes the output of the ls command to the file file.txt.

• echo "Hello, world!" >> file.txt: This command appends the string "Hello, world!" to the end of the file file.txt.

• sort < file.txt > sorted.txt: This command sorts the contents of the file file.txt and writes the sorted output to the file sorted.txt.

• cat file.txt | grep "Hello": This command reads the contents of the file file.txt, pipes the output to the grep command, and filters the output to show only lines containing the string "Hello".

IO redirection can be a powerful tool for managing and processing data on the Linux command line. By redirecting input and output, you can perform a wide range of tasks with ease.

The tee command in Linux allows you to redirect the output of a command to a file and also display it on the terminal at the same time.

The basic syntax for using the tee command is:

command | tee file.txt

This will execute the command and redirect the output to both the file file.txt and the terminal.

You can also append the output to an existing file using the -a option:

command | tee -a file.txt

This will append the output of the command to the end of the file file.txt.

The tee command can be useful for logging output to a file while still being able to see it on the terminal in real-time. It can also be used in conjunction with other commands to perform complex operations on data.

VI editor:

Vi is a powerful text editor that is widely used on Linux and other Unix-like operating systems. It is a command-line based editor that allows users to create, edit, and save text files from within a terminal window.

Vi has a reputation for being difficult to use, with a steep learning curve. However, once users become familiar with its commands and modes, they find that Vi is a highly efficient tool for editing text.

VI editor is a popular text editor in Linux and Unix systems. Here's a list of some of the most commonly used commands in VI editor:

1. i - Switch to Insert mode, allowing you to insert text.

2. esc - Return to command mode from Insert mode.

3. x - Delete the character under the cursor.

4. dd - Delete the current line.

5. d3d - Delete 3 line from current line

6. u - To undo the previous change

7. :w - Save the current file.

8. :q - Quit the editor.

9. :wq - Save the current file and quit the editor.

10. :q! - Quit the editor without saving changes.

11. yy - Yank (copy) the current line.

12. p - Paste the contents of the clipboard after the cursor.

13. /searchterm - Search for the specified term in the file.

14. n - Find the next occurrence of the search term.

15. :set number - Display line numbers.

16. :set nonumber - Hide line numbers.

17. :set syntax=language - Set syntax highlighting for a specific programming language.

18. :set tabstop=n - Set the tab width to n spaces.

19. :set expandtab - Use spaces instead of tabs for indentation.

20. :set noexpandtab - Use tabs instead of spaces for indentation.

21. :set autoindent - Automatically indent new lines to match the previous line.

22. :set nowrap - Disable line wrapping.

These are just a few of the many commands available in VI editor. You can find more commands by typing :help in command mode to see the full list of commands and their descriptions.

THANK YOU FOR YOUR VALUABLE TIME !!

Do follow DevOps Community for more 💙

Why would you need to create your own image:-

Either you and your team decided to dockerize the application you're building for ease of shipping and deployment, or you were unable to locate the part or service you wanted to use for your application on DockerHub.

Creating your own image:-

First, we need to understand what we are containerizing, what application we are creating an image for, and how the application is built.

Step 1:- Create a file with the name "Dockerfile" in the project folder.

Step 2:- In the Dockerfile a simple instruction and argument approach is followed.

[instruction] [argument]

All the instructions are on the left and are typed in all caps. Each of these instructions instructs Docker to perform a certain action while creating the image.

Let's start from the beginning of the Dockerfile.

The first line contains the base image. Every Docker image must be based on another image. This means the installation of the base image is what we require in our image. So that when the container of our image runs we can access all the commands associated with the base image.

FROM <Base_Image>

"It is important that every Dockerfile must start with FROM instruction".

Step 3:- In this step RUN instruction is used. We add all the commands which install and update dependencies that are essential for our project to execute.

RUN <Command>

Step 4:- Now we use the COPY instruction to copy files from the local system into the docker image. This is done because the project that we want to execute is in our local system and we want to make our project available to the docker image.

COPY <Source> <Destination>

Step 5:- This is the final step in the creation of our Dockerfile. This step involves CMD instruction which stands for command and defines the command that will be run within the container when it starts.

CMD [Command]

The final file should look something like this:-

Step 6:- Now that we've finally completed our Dockerfile. It's time to build it.

To build it we'll use docker build -t my_app:1.0 <Location_of_the_Dockerfile>

Step 7:- The last step is to run the Docker image using docker run my_app:1.0

Congratulation you have successfully built your own Dockerfile and now it is running on your system.

Now try it for yourself and dockerize any project you want to. All the best.

Thank you for reading. Do leave a like or a comment if you found this blog to be helpful.

Feedback is highly appreciated.

Follow me on Twitter at sachintwts for more content like this.

K8s is shorthand for "Kubernetes," which is an open-source platform for automating deployment, scaling, and management of containerized applications. It provides a way to manage multiple containers as a single unit, known as a "pod," and can be used to run, deploy, and manage containerized applications in a cluster of machines.

Why use Kubernetes?

K8s help in many tasks, some of the key features of K8s are:-

• Container orchestration: K8s enables the deployment, scaling, and management of containerized applications, making it easier for developers to build, deploy, and manage their applications in a production environment.​

• Automated scaling: K8s can automatically scale resources (e.g. CPU, memory, and storage) based on the needs of the applications, ensuring that resources are used efficiently and cost-effectively.​

• Load balancing: K8s can automatically distribute incoming traffic across multiple replicas of an application, providing high availability and resilience against failures.​

• Self-healing: K8s can automatically detect and recover from failures, ensuring that applications are highly available and always running.​

• Configuration management: K8s provides a centralized way to manage and store configuration information, making it easier to manage complex application deployments.​

K8s Architecture

K8s Architecture mainly consists of 2 components Control Plane(Also called Master Node before) and Worker nodes. We communicate with the Control Plane through the CLI of K8s called kubectl. Control Plane divided the traffic and schedules the pods, pods are situated in the worker node, So we can say the worker node is where the application is going to run and the control plane is going to manage the worker nodes. Now Let's Discuss Each Component of the Control Plane and Worker Nodes.

Control Plane

The Control Plane refers to a set of components that manage the state of the cluster and enforce the desired state of the system. The control plane components are responsible for maintaining the overall health and stability of the cluster and ensuring that the desired state of the system is maintained.

Components of Control Plane

1. API Server

   The API Server is the central component that exposes the K8s API and serves as the front end for all cluster operations. It processes REST operations and acts as a bridge between the control plane and the etcd store. The API Server is responsible for maintaining the overall state of the cluster, including the current state of all objects such as Pods, Services, and Deployments.

2. etcd

   etcd is a distributed, consistent key-value store used to store the configuration data for the cluster. It serves as the primary datastore for the cluster and holds all the information about the state of the system, including the current state of all objects. etcd is designed to be highly available, meaning that even if a node fails, the data stored in etcd is still available to the remaining nodes.

3. Controller Manager

   The Controller Manager is a component that runs various controllers such as Replication Controller, Endpoint Controller, Namespace Controller, Node Controller, Service Account and Token Controllers and others, which handle routine tasks such as replicating Pods, managing node health, and handling endpoints. The Controller Manager is responsible for maintaining the desired state of the system and ensuring that any deviations from the desired state are corrected.

4. Scheduler

   The Scheduler is responsible for assigning Pods to nodes based on resource availability and other constraints. It determines the best node to run a Pod on and ensures that the resources required by the Pod are available on the chosen node. But the Scheduler only decides on which node the pod should be scheduled but the component which actually schedules the pod and starts the pod on the node is called KUBELET.

Worker Node

The worker node is responsible for executing and managing the containers that make up the applications in a cluster. It does this by performing many tasks such as Container Scheduling, Container Execution and Networking with the help of different components. It works closely with the control plane components to ensure that containers are running correctly and that the desired state of the system is maintained.

Components of Worker Node

1. Container runtime

   A container runtime is software that runs containers on a node. Common container runtimes include Docker and rkt. The container runtime is responsible for starting and stopping containers, monitoring the health of containers, and reporting the status of containers to the control plane.

2. Kubelet

   The Kubelet is the primary agent running on each worker node. It communicates with the API server to receive commands to execute and reports the status of the node and its containers. The Kubelet is responsible for starting and stopping containers, managing volumes, and reporting the resource usage of the node to the control plane.

3. kube-proxy

   The kube-proxy is a network proxy that runs on each worker node. It is responsible for implementing the Kubernetes network model, which includes configuring network routes and enforcing network policies.

   or in simple language

   Since many applications are running inside the node, so if any application replica is making a request for a database, instead of the service randomly forwarding the request to any replica it actually forwards it to the replica that is running on the same node that initiated the request.

4. Pods

   Pods are the smallest and simplest deployable units in Kubernetes. They represent a single instance of a running process in the cluster. A pod contains one or more containers, and all containers in a pod run on the same node and share the same network namespace. This means that they can communicate with each other using localhost, and share the same IP address, hostname, and network resources.

5. Container network interface (CNI)

   The CNI is a pluggable interface for connecting containers to a network. The CNI provides the necessary network configuration for containers, such as assigning IP addresses and configuring network routes

Components of Kubernetes

1. Services

Services provide stable network identities for pods and are used to expose applications running in the cluster to external clients. Services provide a stable IP address and DNS name for pods, allowing external clients to communicate with the application even if the pods themselves are rescheduled to different nodes.

Types of Services

1. ClusterIP

   A ClusterIP service is the default service type in Kubernetes. It provides a stable IP address and DNS name for pods, allowing external clients to communicate with the application even if the pods themselves are rescheduled to different nodes.

2. NodePort

   A NodePort service is a service that exposes a specific port on the nodes in the cluster, allowing external clients to access the application directly. This type of service is useful when an application requires a static IP address or when it needs to be accessible from outside the cluster.

3. LoadBalancer

   A LoadBalancer service is used to provide external access to an application running in the cluster. It provides a stable IP address and DNS name that is load balanced across the nodes in the cluster, ensuring that external clients can access the application even if one or more nodes are unavailable.

4. ExternalName

   An ExternalName service is used to map an external DNS name to a Kubernetes service. This type of service is useful when you want to access an external service from within the cluster without having to create a load balancer or expose a cluster IP address

2. Ingress

Ingress provides external access to services in a cluster. It defines a set of rules for incoming traffic, allowing incoming requests to be directed to the correct service based on the URL or hostname.

Ingress works by providing a single entry point for external clients to access services in a cluster. It acts as a reverse proxy, routing incoming requests to the correct service based on the rules defined in the Ingress resource.

Function of Ingress

1. Load balance incoming traffic

   Ingress can be used to load balance incoming traffic across multiple replicas of a service, ensuring that the traffic is distributed evenly across the available resources.

2. Provide SSL termination

   Ingress can be configured to provide SSL termination, allowing incoming SSL requests to be decrypted and redirected to the correct service in the cluster.

3. Provide authentication and authorization

   Ingress can be configured to enforce authentication and authorization rules, allowing only authorized users to access specific services in the cluster.

3. ConfigMap

A ConfigMap allows you to manage configuration data for your applications. It provides a convenient way to store configuration data that can be easily referenced by your applications.

A ConfigMap is defined as a YAML file that contains key-value pairs. The keys in the ConfigMap can be referenced by environment variables, command-line arguments, or as files stored on disk. This allows you to manage configuration data in a centralized manner, making it easier to manage and update your applications.

ConfigMaps are useful in a number of ways:

1. Separating configuration data from code: By using a ConfigMap to store configuration data, you can keep configuration separate from the code of your applications. This makes it easier to update configuration data without having to update the code of your applications.

2. Sharing configuration data between applications: ConfigMaps can be used to share configuration data between multiple applications, making it easier to manage common configurations across multiple applications.

3. Making configuration data available to containers at runtime: The data stored in a ConfigMap can be easily referenced by containers at runtime, making it easy to manage configuration data for your applications.

4. Secret

A Secret allows you to manage sensitive information, such as passwords, tokens, and SSL certificates. It provides a secure way to store and manage sensitive information in a cluster.

A Secret is defined as a YAML file that contains key-value pairs. The values in a Secret are encoded using base64 encoding, and they can be decoded by containers at runtime. This allows you to store sensitive information in a cluster without having to store it in clear text in your configuration files.

An Example of base64 coded password:-

5. Volumes

Volumes are a way to persist data in a Kubernetes cluster. They allow you to store data that needs to persist even after a container has been deleted, such as data that needs to be shared between containers or data that needs to persist even if the cluster experiences failures or restarts.

Type of Volumes:-

1. EmptyDir: An EmptyDir volume is created when a Pod is created and deleted when the Pod is deleted. It is useful for sharing data between containers within a Pod.

2. HostPath: A HostPath volume mounts a file or directory from the host node file system into a container. It is useful for sharing data between a container and the host node file system.

3. PersistentVolumeClaim: A PersistentVolumeClaim is a request for storage by a user. It is used to dynamically provision storage from a storage class.

6. StatefulSet

StatefulSets is used to manage stateful applications. A stateful application is an application that requires persistent storage, such as a database.

StatefulSets provide several key features to manage stateful applications in a Kubernetes cluster:

1. Stable Network Identities: Each Pod in a StatefulSet is assigned a stable hostname, which allows for the persistence of network identities across Pod restarts.

2. Persistent Storage: StatefulSets provide a way to manage Persistent Volumes (PVs) and Persistent Volume Claims (PVCs), which are used to store data persistently in a Kubernetes cluster.

3. Rolling Updates: StatefulSets provide a way to perform rolling updates to Pods, which allows for updating a stateful application without disrupting its operation.

7. Deployment

Deployment provides a declarative way to manage and update Replication Controllers and Pods.

A Deployment defines the desired state for a set of Pods and ensures that the desired number of replicas are running and available. In case of a failure, the Deployment will automatically recover the Pods to the desired state.

Features of Deployment

1. Rolling Updates: Deployments provide a way to perform rolling updates to Pods, which allows for updating an application without disrupting its operation.

2. Rollback: Deployments provide a way to roll back to a previous version of the application in case of a failure.

3. Scaling: Deployments provide a way to scale up or down the number of replicas of a Pod.

8. Labels and Selectors

Labels and selectors are used to organize and identify resources in a cluster.

Labels are key-value pairs that are attached to resources such as Pods, Services, and Deployments. Labels can be used to describe the characteristics of a resource, such as its environment, role, or version.

Selectors are used to select a set of resources based on their labels. A selector is a set of label requirements, expressed as key-value pairs. For example, a selector can be used to select all Pods that have a label with the key "environment" and value "production".

Resources

• Kubernetes Tutorial for Beginners

• Kubernetes 101 workshop

• Kubernetes website

• Kubernetes Github

Git has two repository types local and remote.

The local repository is on the local machine and the remote is on the central server. We can always pull/push our code/data on remote/local repositories as well and others can also make changes to the code/data.

In Local Repository, data will be passed to the staging area and then commit files. The working area is the untraced state.

What is GitHub?

GitHub is a web-based platform that provides hosting for software development projects that use the Git version control system. It allows developers to store, manage and track changes to their code over time, collaborate with others on projects and contribute to open-source projects.

Differences between git and GitHub:

1. Git is a version control system, while GitHub is a web-based hosting platform for Git repositories.

2. Git allows you to manage and keep track of your source code history locally, while GitHub provides a remote, collaborative environment.

3. Git commands are executed in the terminal, while GitHub offers a graphical user interface to interact with Git repositories.

4. Git is free and open-source, while GitHub offers both free and paid plans for individuals and organizations.

5. Git enables collaboration through remote repository cloning and merging, while GitHub provides additional collaboration features such as pull requests, issues, and project boards.

GIT installation

We can simply install git using this link to any of the platforms and by following the steps:

https://git-scm.com/downloads

I have installed it using home-brew, please find the below commands for the same.

brew install git: To install git 
git --version: to check the current version of git

Git repository:

A Git repository is a virtual storage area where you can save versions of your code. It is used to track changes in your source code over time and collaborate with other developers by sharing your code and contributing to others' code. The repository contains all the files, branches, and history of changes that have been made to the code.

Git Init:

The git init command is the first command that you will run on Git. The git init command is used to create a new blank repository. It is used to make an existing project a Git project. Several Git commands run inside the repository, but the init command can be run outside of the repository.

#git init : It is used to initialising git

Git Add:

The git add command is used to add file contents to the Index (Staging Area). This command updates the current content of the working tree to the staging area. It also prepares the staged content for the next commit. Every time we add or update any file in our project, it is required to forward updates to the staging area.

#git add <file_name>: It is used to put data in staging area

Git Status:

The git status command is used to display the state of the repository and staging area. It allows us to see the tracked, untracked files and changes. This command will not show any commit records or information.

Mostly, it is used to display the state between Git Add and Git commit commands. We can check whether the changes and files are tracked or not.

#git status: To check the status of data , after git add it should be in staging area

At times, we have to let it know who is making the changes in git to make a record of the changes.

#git config [user.name](http://user.name) “aman”

#git config [user.email](http://user.email) “aman@example.com”

Here are a few more useful commands :

#git restore “file.txt” : It will store the previous version of file. 

#git commit -m “updated text” : It will update the create a new story and saves the new copy of the story, this way we can avoid going to the text editor and updating it. 

#git add . : with this command we can stage more than one file in staging area 

#git log: To get the log details 

#git log --name-only: Detailed logs with file names 

#git log -n 1 : latest commit in the new repository.

GIT Braches:

In Git, branches are separate copies of a project that can be worked on independently. It is used to avoid mistakes in the master branch and separately we can run the code through git and test it.

They allow multiple team members to work on different features or bug fixes simultaneously without interfering with each other. Branches have their own set of commits and changes made on one branch do not affect the others. Developers can create pull requests to merge changes from one branch to another. The main branch is called "master" and is considered stable. Git flow is a branching model that helps Organise and track work in a structured way for large projects.

#git branch “branch_name” : Create a new branch 

#git checkout “branch_name”: switch to an existing branch

#git checkout -b “branch_name”: create a new branch and switch to it 

#git branch -d “branch_name: To delete the branch ‘d stands for delete’

#git branch: List all the branches 

#git branch -a: Lists all branches in the local and remote repository.

# git merge “branch_name”: 1. Merges the specified branch into the current branch. ( It can be done through master branch)

Note: fast-forward merge: It can happen when the current branch has no extra commits compared to the branch which we are merging.

#git pull "remote" "branch_name": Fetches the specified branch from the remote repository and merges it into the current branch.

# git branch -D "branch_name": Force deletes the specified branch.

#git branch -m "old_branch" "new_branch": Renames the specified branch.

#git stash: Stashes changes in the working directory, allowing you to switch branches without committing changes.

#git stash apply: Applies the changes stashed in the last stash command.

Head: It is the current location in the repository, it will move automatically whenever we switch branches.

As you can see the HEAD always points to the last commit on the currently checked-out branch.

Git Remote:

In Git, the term remote is concerned with the remote repository. It is a shared repository that all team members use to exchange their changes. A remote repository is stored on code hosting services like an internal server, GitHub, Subversion, and more.

git remote: The given command is providing the remote name as the origin. Origin is the default name for the remote server, which is given by Git.
git remote -v: The above output is providing available remote connections. If a repository contains more than one remote connection, this command will list them all.

Git Push, pull & clone:

The git push command is used to upload local commits to a remote repository. The syntax for the command is as follows:

git push [remote-name] [branch-name]

Where remote-name is the name of the remote repository, and branch-name is the name of the branch that you want to push to the remote repository. This command is typically used after making local changes and committing them to your local repository, to share those changes with others who are collaborating on the project.

git pull is a command used in Git to retrieve new changes from a remote repository and merge them into the current branch. It is a combination of git fetch and git merge commands and is typically used to synchronize a local repository with a remote one.

git pull <remote> <branch>

where <remote> is the name of the remote repository and <branch> is the name of the branch you want to pull changes from.

git clone: The git clone command is used to create a copy of a remote repository on a local machine.

git clone [remote-repository-url]

Where remote-repository-URL is the URL of the remote repository that you want to clone. This command creates a new directory with the same name as the remote repository and copies all of the files and their history into the new directory. This is useful for creating local copies of remote repositories for development or collaboration.

Git Fetch and Merge:

Git Fetch: Git Fetch is a command used in Git to retrieve new changes from a remote repository and bring them into the local repository. It is typically used to synchronize a local repository with a remote one. The command retrieves the changes but does not merge them into the local repository, allowing the user to review the changes before merging them. The command is used in the following format:

git fetch <remote> <branch>

where <remote. is the name of the remote repository and <branch> is the name of the branch you want to fetch the changes from. If no branch is specified, git fetch retrieves changes from all branches of the remote repository.

Git Merge: git merge is a command used in Git to combine changes from multiple branches into the current branch. It is typically used to bring changes from a remote branch into the local branch that you are currently working on.

git merge <branch>

where <branch> is the name of the branch you want to merge into the current branch.

For Ex: If we have two commit messages from two different users we can correct them (Incase of wrong msgs) and commit the changes with new changes.

Fork:

A fork in Git is simply a copy of an existing repository in which the new owner disconnects the codebase from previous committers. A fork often occurs when a developer becomes dissatisfied or disillusioned with the direction of a project and wants to detach their work from that of the original project.

A git fork is a feature of Git and GitHub that allows users to create a separate copy of a repository under their account. This allows users to make changes to the code and propose changes to the original repository.

On the other hand, git clone is a command used to copy an existing Git repository from a remote server to a local computer, git clone creates a local copy of the entire repository, including all branches, commits, and history. The cloned repository is linked to the original repository, so changes can be easily synced between the two.

In summary, git fork is a feature of Git and GitHub that enables users to create a separate copy of a repository, while git clone is a Git command used to create a local copy of a remote repository, The main difference is that git fork creates a separate copy under a different account, while git clone creates a local copy of the entire repository.

Git rebase:

Git rebase is a command used to reapply commits from one branch on top of another branch. The **git rebase**command is used to perform this operation. The main use of rebasing is to clean up a feature branch by removing unnecessary merge commits and making a linear history, making it easier to understand and maintain the branch.

git rebase master

In general, **git merge**is a safer option for integrating changes in a collaborative environment, as it preserves the history of both branches and makes it clear when and how changes were integrated. On the other hand, **git rebase**can be useful for cleaning up a branch's history and avoiding multiple merge commits, but it should only be used in a non-collaborative environment or with caution in a collaborative one.

git cherry-pick:

**git cherry-pick**is a Git command that allows you to select and apply specific commits from one branch onto another branch. This can be useful when you want to apply specific changes from a branch without merging the entire branch into yours.

git cherry-pick <hash of the commit >

Git Revert and Reset:

Git Revert: Used to revert the commit already done, it is used to undo changes and keep those changes in the git history. Below are two general commands that we use, there are a few more commands.

git revert <commit-ish>: The commit option is used to revert a commit. To revert a commit, we need the commit reference id. The git log command can access it.
git revert -e <commit-ish>: It is used to edit the commit message before reverting the commit. ( -e stands for edit)

Git Reset: "git reset" is a Git command that is used to reset the state of your Git repository to a specific commit or a specific state. The reset command can be used to unstaged changes, to unmodified files, or to reset the branch pointer to a different commit.

There are three main options for git reset;--mixed, --soft, and --hard. The default option is --mixed, which resets the branch pointer to the specified commit, but keeps the changes in the working directory and index, allowing you to review and recommit the changes if desired.

git reset [commit]: Resetting the branch pointer to a specific commit:
git reset: This command unstages changes, leaving them in the working directory.
git reset [file]: This command unmodifies the specified file, leaving it in the working directory.
git reset --hard [commit]: This command resets the branch and index to the specified commit, discarding all changes in the working directory.

Here is a picture that will help you to understand more:

Stashing:

"Stashing" in Git is a way to temporarily save changes that have not yet been committed to a branch. This allows you to switch to a different branch, perform some other work, and then later come back and apply the stashed changes. The stash is stored as a "stack" of changes, so you can have multiple stashes and choose which one to apply later.

git stash : To save the changes 
git stash save "<Stashing Message>" : We can save the changes with a message
git stash list: It gives the list of all stash changes with stash@{} ID. 
git stash apply: command is used to reapply changes that were previously stashed using git stash. This allows you to switch back to a branch you were working on, apply the stashed changes, and continue your work.
git stash apply <stash id>: It will save the changes to the stage were you want. 
git stash show: This command will show the file that is stashed and changes made on them.
git stash show -p: -p stands for the partial stash. The given command will show the edited files and content.
git stash pop: It is a Git command that combines the functionality of both git stash apply and git stash drop. It reapplies the changes from the most recent stash, and then removes the stash from the stash list.
git stash drop: This command is used to delete a stash from the queue. Generally, it deletes the most recent stash.
git stash drop <stash id>: To delete a particular stash from the queue.
git stash clearL: This command allows deleting all the available stashes at once.
git stash branch <Branch Name>: This command will create a new branch and transfer the stashed work on that.

Git Reflog:

"git reflog" is a Git command that provides a log of changes to the state of your Git repository, including branch references and HEAD. The reflog is stored in the .git/logs/ directory and is a record of all changes to the branches and HEAD in your repository, including branch updates, resets, and other operations.

The reflog is useful in a variety of situations, including:

1. Recovering lost commits: If you have lost a commit or made a mistake during a reset or rebase operation, you can use the reflog to find the commit and recover it.

2. Debugging repository state: If you are unsure of the state of your repository, you can use the reflog to see all the changes that have been made, and how they have affected the branches and HEAD.

3. Undoing operations: If you have made a mistake or want to undo an operation, you can use the reflog to find the state of the repository before the operation and reset the repository to that state.

git reflog: Gives all the alternation done previously. Its shows all the changes in the repo

git reset --hard [commit-reference-in-reflog]: The git reflog command is an essential tool for Git users, as it provides a way to recover from mistakes and track changes to the state of the repository. It is recommended that you regularly run git reflog to keep track of changes to your repository and to ensure that you have a way to recover from mistakes.

GIT Object Contents:

1. Commit: It is simply a commit.

2. Tree: It is a folder on our File system, associated with a repository.

3. blob: It is just a piece of data.

NOTE: All the commits are saved in ./.git/objects folder.

Thank you for your valuable time !!

Ansible is an open-source automation platform that can help you manage and control various nodes from a central location. It allows you to automate tasks, including configuration management, application deployment, and task execution.

It is a radically simple IT automation platform that makes your applications and systems easier to deploy. Avoid writing scripts or custom code to deploy and update your applications— automate in a language that approaches plain English, using SSH, with no agents to install on remote systems.

Some key features of ansible include:

1. Simple to use: Ansible uses an easy-to-learn language (YAML)and has a simple, straightforward architecture.

2. Agentless: ansible does not require any additional software to be installed on managed nodes.

3. Idempotent: ansible tasks are designed to be run multiple times without causing unintended side effects.

4. Large community and support: ansible is an open-source platform with a large user base, meaning there is a wealth of resources and support available.

What Are the Benefits of Learning Ansible Basics?

• A free and open-source community project with a huge audience.

• Battle-tested over many years as the preferred tool of IT wizards.

• Easy to start and use from day one, without the need for any special coding skills.

• Simple deployment workflow without any extra agents.

• Includes some sophisticated features around modularity and reusability that come in handy as users become more proficient.

• Extensive and comprehensive official documentation that is complemented by a plethora of online material produced by its community.

Ansible Architecture:

From the diagram above, we understand that visibility comes into play:

1. Everything from servers to desktop computers to network configurations and applications can all be stored in a Public/Private Cloud.

2. It demonstrates that it has all the features of a sizable cloud platform, but it also allows users to communicate with all of the modules and API. It also demonstrates that it has security measures.

3. An inventory file contains devices, groups, host variables, templates, and tasks. Along with the inventory file, playbooks must be created that describe how to handle all the devices, groups, host variables, and templates.

4. Once Ansible has a task or set of tasks in a playbook to run, it needs to know where to run those tasks. It needs an inventory of hosts. Ansible has a concept called “inventories” that consist of lists of hosts to perform actions stored in files such as YAML.

5. Modules in Ansible allow you to interact with the cloud like Azure or on-prem resources like Hyper-V. An Ansible module is a standalone, reusable script that can be used with the Ansible API. They can also be used by Ansible playbooks. One of the key factors of an Ansible module is that they are reusable and not meant for just one environment.

6. The augmented ansible core is created by combining all of the cache, logging purposes, ansible’s functioning, and so on.

7. It allows for the creation of various agentless frames that can be utilized in multiple automated networks.

8. A single repository can contain all the computers of an operational or IT infrastructure network.

9. Ansible is being used to make Linux and Unix machines automated.

10. It provides the needed APIs for the interaction of the end-to-end modules.

Ansible modules

Ansible Modules are pre-written pieces of code that can be used in ansible playbooks to perform specific tasks. There are hundreds of modules available, and they can be used to manage everything from software installations to server configurations.

Here is an example of an ansible copy module:

Ansible playbook

Ansible playbook is a YAML file that defines a series of tasks to be executed by Ansible. It specifies the managed nodes on which the tasks should be run and the order in which they should be executed.

Here is a list of the most commonly used Ansible Modules:

1. Ansible Package Module: Used to install, upgrade, and remove packages on remote hosts.

2. Ansible Service Module: Used to manage services on remote hosts.

3 Ansible File Module: Used to manage files and directories on remote hosts.

4. Ansible Copy Module: Used to copy files from the local machine to the remote hosts.

5. Ansible Fetch Module: Used to fetch files from remote hosts to the local machine.

6. Ansible Template Module: Used to create configuration files from templates.

7. Ansible Shell Module: Used to execute shell commands on remote hosts.

8. Ansible Debug Module: Used to print out debugging information.

9. Ansible Setup Module: Used to collect information about remote hosts.

10. Ansible Git Module: Used to manage git repositories on remote hosts.

11. Ansible Yum Module: Used to manage packages on Red Hat-based systems.

12. Ansible Apt Module: Used to manage packages on Debian-based systems.

13. Ansible Command Module: Used to execute commands on remote hosts.

14. Ansible Script Module: Used to execute scripts on remote hosts.

15. Ansible Cron Module: Used to manage cron jobs on remote hosts.

16. Ansible User Module: Used to manage user accounts on remote hosts.

17. Ansible Group Module: Used to manage user groups on remote hosts.

18. Ansible SELinux Module: Used to manage SELinux policies on remote hosts.

19. Ansible Firewall Module: Used to manage firewall rules on remote hosts.

20. Ansible Cloud Modules (AWS, GCP, Azure, etc.): Used to manage cloud resources on remote hosts.

Ansible Inventory is a way for Ansible to track the information about the systems it is managing. It is a collection of data that describes the hosts and their characteristics. The inventory can be a simple list of hostnames or IP addresses, or it can be a more complex file that describes the hosts in groups and includes additional information about each host.

Ansible conditions

Ansible conditions allow you to control the flow of execution in your playbooks and tasks based on certain conditions. The most common way to use conditions in Ansible is by using the when statement. "when" statement is used to specify a condition that must be met before a task is executed.

Here is a simple example for the same, you can always use them according to the conditions and your convenience.

Ansible roles

Ansible roles are a way to organize and reuse Ansible tasks, files, and variables. Each role is defined in a single directory and it has a specific name that can be referenced in the playbook. Roles can be stored in the Ansible galaxy or in a local directory.

Ansible Galaxy

Ansible Galaxy is a public library of Ansible roles that can be easily downloaded and used in your playbooks. Ansible Galaxy is a command-line tool that is included with the Ansible installation, so you don't have to install it separately. And the enterprise version is in GUI as well offered by Red-hat.

The command to install ansible-galaxy is below. You can also find more about ansible-galaxy on https://galaxy.ansible.com/

Ansible Tower

Ansible Tower is a management tool for Ansible, an open-source automation engine that automates software provisioning, configuration management, and application deployment. Ansible Tower provides a centralized interface for managing and organizing Ansible automation in an enterprise environment.

• Role-based access control: Allows users to control access to Ansible automation based on roles and permissions.

• Scheduling: Allows users to schedule Ansible automation to run at specific times or specific intervals.

• Notifications: Allows users to receive notifications when automation runs or when certain events occur.

• Reporting: Provides detailed reporting on the execution of Ansible automation, including success rates, run times, and output.

• APIs: Provides a RESTful API for automating and integrating Ansible Tower with other tools and systems.

Ansible tower is used in IT operations and DevOps teams to automate repetitive tasks, quickly deploy applications and manage infrastructure. It provides a graphical user interface to manage Ansible playbooks, inventory, and scheduled jobs. It also allows you to delegate certain automation tasks to specific teams or individuals and provides reporting and analytics to track and measure automation success.

Ansible loops

Ansible loops allow you to repeat tasks or actions multiple times, based on a set of data. Loops are defined using the with_*keywords, where *is the type of loop you want to use. There are several types of loops in Ansible, including with_items, with_dict, with_file, with_sequence and with_subelements, each with its use cases.

Here is an example of using the with_items loop to install multiple packages, Also we can always use it according to our convenience like dictionary, file, sequence etc.

Ansible Variables

Ansible Variables: Ansible uses variables to manage differences between systems. With Ansible, you can execute tasks and playbooks on multiple different systems with a single command. To represent the variations among those different systems, you can create variables with standard YAML syntax, including lists and dictionaries. You can define these variables in your playbooks, in your inventory, in reusable files or roles, or at the command line. You can also create variables during a playbook run by registering the return value or values of a task as a new variable.

Thank you all for giving your valuable time for reading.

Resources :

#Kunal Kushwaha

#WeMakeDevs

#Techworld with Nana

#Kodekloud

In simple words, Docker is a tool that allows developers, sys-admins, etc., to easily deploy their applications in containers to run on the host operating system, i.e. Linux.

The primary advantage of Docker is that it enables developers to compile a program and all of its dependencies into a single, standardized unit for software development. It allows developers to package and distribute their applications fast, consistently, and reliably. It also makes it easy to run those applications in various environments, such as on a developer's local machine, in a testing environment, or in a production environment.
Docker also makes it easier to scale applications, as containers can be easily moved from one host to another.

What was before Docker?

Not Docker in particular, but before containers, there were operating system virtualization, chroot, and resource isolation.
OS-virtualization, which involves creating multiple virtual environments(VMs) on a single physical host. Which can run their own operating systems and applications and are isolated from each other. Operating system virtualization has been around for decades and is still in use today.
Another technology that preceded containers is chroot, which allows a user to change the root directory for a process and its children. This can be used to isolate a process and its dependencies from the rest of the system.
Overall, containers build upon these and other technologies and concepts to provide a lightweight and portable way to isolate and run applications.

Advantages of Docker

Containers have several advantages over prior technologies, such as they are more Lightweight, Portable, and Isolated. Containers also allow developers to package and distribute applications consistently, making it easier to develop and test applications. It can be easily automated, which can save time and reduce the risk of errors when building, testing, and deploying applications.

Overall, containers offer a lightweight and efficient way to isolate and run applications, making them an attractive option for developers.

If you are already a Developer or just started with development (Frontend, Backend, Node dev, Python-dev, etc) knowledge of Containers will be incredibly beneficial to your development journey. And if you are planning to learn DevOps it is something necessary to know. This Blog on Docker will help you learn the Docker & container concepts very easily, with examples.

Prerequisites

There are no particular skills needed for this tutorial beyond a basic comfort with the UNIX command line and using a text editor. Prior experience in developing web applications will be beneficial but is not required. If you're interested in following along, please create an account on Docker Hub.

Let's do a hands-on on Docker containers.

To work with Docker, it is not necessary to know the Docker architecture or how Docker works [You can see that here.], but we need to understand some of the terms.

1. Image: A Docker image is a lightweight, standalone, and executable package that includes everything an application needs to run, including the application code, libraries, dependencies, and runtime.

2. Container: A Docker container is a running instance of a Docker image. A container allows an application to be run in a lightweight, isolated environment.

3. Registry: A Docker registry is a centralized storage location for Docker images. Docker provides a free public registry called Docker Hub, which allows users to store and distribute their images.

4. Dockerfile: A Dockerfile is a text file that contains the instructions for building a Docker image. It specifies the base image, the dependencies, and the commands needed to run the application.

Let's run the first command.

docker run hello-world

If your system is running Docker properly, you should have an output saying, "Hello from Docker!"

docker run <IMAGE_NAME> is just spinning up containers of the specified image.

You can also see the 2^nd and the 3 ^rd lines where the docker first searches for the image locally, and if it is unable to find it, it goes and look at the DockerHub and pull the image from there.

There are many flags we can use in the docker run like --name <CONTAINER_NAME> that will give a specified name to the container, which we can use to refer to instead of the container ID; we also use the -d flag which will run the container in the background and print out the container ID.

But you might ask, Hey Debasish, what do you mean by background? Where is the information about containers running in the background? How can I access them?

Trust me, we will explore that.

docker run -d --name myNginx nginx

This command will run a container in the background with the name "myNginx". If you remove the -d flag, you will see that the terminal has frozen. Because the container will take over the terminal.

Now, if you run docker container ls, you can see the information about all the running containers(you can also use docker ps). Container ID, image name, status, ports, and container name.

Ok, so my Ngnix server is running, but how can I access it? Can I simply curl http://localhost:80? If you try this, you will not get any response. Now you may say, "hey Debasish though my Nginx server is running, why wouldn't I be able to use it? Or how can I access my Nginx server?"

The answer is that the container is running on our local machine, but the Nginx server we are trying to access is actually running inside the container. A container is not the server or the application we will run on the Docker but the isolated environment where our applications or servers will run. So we will be able to access the server from inside the container.

So, how can we go inside the container?

docker exec -it myNginx bash

Booom, we are inside the container, and your terminal initials will look like root@<container_id>:/#. Now you can curl http://localhost:80, and we will get the raw nginx home page as a response from the server.

Here docker exec <container_id> <command> will run the specified command inside the corresponding container, and -it is for an interactive terminal, so after opening the container's bash shell, we will stay inside. We can also run any command and open any other available shell, i.e., sh, bash etc.

There is another way to access any serving port from outside the container, and we can poke a hole into the container, publish port no inside the container, and forward it to an external port. We can do it while starting the container.

Let's stop the running container first by running.

docker container stop myNginx

Now let's start the container again while publishing container port 80 to port 8080 into our local machine.

docker run -d -p 8080:80 --name portNginx nginx

-p <host_port_no>:<container_port_no> now we can access the Nginx home page by requesting http://localhost:8080. It will forward the request to the container port 80 and get back the response from there.

There are also some basic commands like

1. docker search: Search the Docker Hub for images. Use the docker search command followed by the search term.

    docker search ubuntu
   

2. docker pull: To pull an image or a repository from a registry, use the docker pull command followed by the image or repository name.

    docker pull ubuntu:18.04
   

3. docker stop: To stop a running container, use the docker stop command followed by the container name or ID.

   First, we start the container by docker run --name my-container ubuntu:18.04

    docker stop my-container
   

4. docker start: To start a stopped container, use the docker start command followed by the container name or ID.

    docker start my-container
   

5. docker rm: To remove one or more containers, use the docker rm command followed by the container name or ID.

    docker rm my-container
   

   We need to use -f to remove a running container forcefully.

6. docker rmi : To remove one or more images, use the docker rmi command followed by the image name or ID.

    docker rmi ubuntu:18.04
   

7. docker inspect: To display detailed information about a Docker container or image. You can specify the name or ID of the container or image as an argument.

   For example, to inspect a container called my-container, we can use the following command:

    docker inspect my-container
   

   This will display detailed information about the my-container container, including the container's ID, name, state, image, and configuration.

Link to Part 2

In part 2, we will dive deeply into Dockerfile, how to build and dockerize applications, push them to DockerHub, and learn about Docker volume and Docker networks.

And you are here to read about (CICD) Let's talk about cicd what is it? why it's involved in our lives? i will make sure after reading this blog, you can breathe good stuff regarding CICD and you will get a clear idea regarding it.

Now, let's understand what is ci and cd.

CI (continuous integration):-

Let's think about a situation if we as a developer developed a code and shared it to a codebase such as a git repository, where people in our team also share their version of the code.

And we are doing this continuously for weeks and the code works fine in the development area. but after testing suppose it's failing in the deployment server or building stage or any other stage.

Again you need to look back into the issue and it's not time efficient and cost-efficient also. so what if the code is tested at the same time as committing the changes, and how good it will be if we find out the errors at the initial stage of developing the code itself and fixing them.

It will be good and this method is time efficient and also cost-efficient. So the explanation of continuous integration is -->

****the moment when we commit the code into a repository at that instance itself the process of build and automation test initiates, so we will be confident enough that our code is working fine.

. And this happens for every commit that we make.

. So with this continuous integration, we will easily look up the issues in the early stages instead of writing the entire code for weeks and testing it later.

now let's what is "CONTINOUS DEPLOYMENT" ---->

CD(continuous deployment) :-

see many of us think that continuous delivery and continuous deployment is the same, but they are not.

let's talk first about

continuous delivery:-

suppose if a client asks what the update of the work, so here we need to show our work on a mock server where the client can see the progress of the work instead of directly deploying on the production environment, we create a mock server and push our work(code) there, it's known as continuous delivery.

now we see what is

continuous deployment:-

Hereafter integration we are having our code right which had gone through some automation and build tests,

so from there, the code is deployed directly to the production server, which means after we make a commit it directly hits the production environment(after a few tests).

so if there is any mishap then gone so it's a little scary.

And many companies won't opt for the CD they also Opt for CI.

so for the safe side, they go by manual deployment.

now after seeing the above picture hope we people got a good understanding.

And for this cicd process, there are many tools in the market but we look at some famous tools.

They are GITLAB, JENKINS, AZURE DEVOPS, TRAVIS CI

GITLAB - A built-in continuous integration and delivery service for GitLab, an open-source git management tool.

JENKINS - One of the most widely used open-source CI/CD tools. It provides a wide range of plugins for building, testing, and deploying code, and is highly customizable.

AZURE DEVOPS - A set of cloud-based tools from Microsoft that includes Azure Pipelines, a CI/CD service that supports multiple languages and platforms.

TRAVIS CI - A cloud-based CI/CD service that is popular among open-source projects. It integrates with GitHub and is easy to set up

But I prefer GITLAB because we can do any things in one place, And we can manage source code also since it integrates with git and Git Hub easily.

Now let's get into cicd explanation and what stages are involved.

There will be five stages in cicd namely --

• Source Code Management

• Build

• Test

• Deployment

• Monitoring

we see this in detail -

Source Code Management

It is the first stage and it involves pulling code changes from a version control system (VCS) such as Git. This is where the developers push the code for review and testing.

Build

The second stage is to build the code, typically using a build tool such as Maven or Gradle. This step compiles the code, runs static analysis and unit tests, and produces the necessary artifacts (e.g. jar, war, or executable)

Test

In this test, we make the code undergo a few automation tests in different environments. Mainly the tests are like unit tests, integration tests etc.

Deployment

If the tests pass, the pipeline progresses to deployment. The artifacts are deployed to a staging environment for further testing by QA teams and then subsequently to production for end-users to use.

but here I need to give an introduction to the word pipeline,

Basically, the pipeline is typically made up of a series of steps or stages, each of which represents a specific task or set of tasks in the software development process.

we do all the above things in one place and we call it a pipeline***.***

Monitoring

This last stage is to monitor the deployed application for performance, errors, and other issues, and to quickly address any problems that arise.

I want to explain the hands-on of this process as well but will do it in another blog coz I don't want to extend this further.

HAPPY LEARNING :)