Debug School: Umashankar

Kubernetes FAQ

Umashankar — Fri, 21 Jul 2023 13:28:23 +0000

What is Kubernetes?

Kubernetes (K8s) is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF). Kubernetes provides a robust and flexible infrastructure for running applications in a highly scalable and fault-tolerant manner.

Why We need Kubernetes?
Kubernetes is a powerful and popular open-source container orchestration platform that is widely used in the world of modern software development and deployment. It addresses several critical challenges that arise when managing containerized applications at scale. Here are some reasons why we need Kubernetes:
Automated Deployment and Scaling
Container Orchestration
Load Balancing and Service Discovery
Rolling Updates and Rollbacks
Declarative Configuration:

How Kubernetes works?
Kubernetes works as a distributed system that manages containerized applications across a cluster of nodes (servers). It follows a master-worker architecture, with the master being responsible for overall cluster management and the workers (also called nodes) running the actual containers. Here's an overview of how Kubernetes works:

Nodes (Workers): A node is a physical or virtual machine that runs containers. Each node has a Kubernetes agent called "kubelet" that communicates with the master and ensures that containers are running as expected on the node. Nodes also have a container runtime (e.g., Docker, containerd) responsible for pulling and running container images.

Master: The master is the control plane of Kubernetes, responsible for managing the entire cluster. It consists of several components:

API Server: It serves as the frontend to the Kubernetes control plane. It validates and processes RESTful API requests, manages the state of all objects in the cluster (e.g., pods, services, deployments), and communicates with the etcd datastore.

etcd: It is a distributed key-value store that stores the cluster's configuration data, representing the desired state of the cluster. The API server reads from and writes to etcd to maintain the current state of the cluster.

Controller Manager: It runs various controllers responsible for maintaining the desired state of the cluster. For example, the ReplicaSet controller ensures the specified number of replicas of a pod is running, and the Deployment controller manages updates and rollbacks of application deployments.

Scheduler: The scheduler is responsible for placing pods onto nodes based on resource requirements, node capacity, and other constraints. It helps balance workloads across the cluster.

Pods: A pod is the smallest deployable unit in Kubernetes. It represents one or more tightly coupled containers sharing network and storage namespaces. Containers within a pod can communicate with each other using localhost, making it easier to design and deploy multi-container applications.

ReplicaSets and Deployments: ReplicaSets are responsible for ensuring a specified number of replicas (identical pods) are running in the cluster. Deployments build on top of ReplicaSets and allow declarative updates and rollbacks of applications. When you update a Deployment, it creates a new ReplicaSet with the updated version and gradually scales it up while scaling down the old version.

Services: A Service is an abstraction that defines a stable endpoint (IP address and port) to access one or more pods. It provides load balancing across multiple pods, ensuring high availability and easy service discovery.

Ingress: An Ingress is a resource that manages external access to services within the cluster. It allows you to define routing rules and SSL termination for incoming traffic.

ConfigMaps and Secrets: ConfigMaps hold configuration data as key-value pairs, which can be consumed by pods as environment variables or mounted as volumes. Secrets are similar but specifically designed to store sensitive data, like passwords or API keys, in an encrypted format.

What is Pods?
In Kubernetes, a pod is the smallest and simplest deployable unit that represents a single instance of a running process in a cluster. It is the fundamental building block for deploying containerized applications. A pod encapsulates one or more tightly coupled containers, storage resources, a unique network IP, and options for how to run the containers.

A Kubernetes pod is a collection of one or more Linux containers, and is the smallest unit of a Kubernetes application. Any given pod can be composed of multiple, tightly coupled containers (an advanced use case) or just a single container (a more common use case). Containers are grouped into Kubernetes pods in order to increase the intelligence of resource sharing

Run shell script and display output

Umashankar — Thu, 20 Jul 2023 13:52:27 +0000

root@ip-172-31-87-83:~/uma# ansible-playbook -i inventory gitget.yaml -u ubuntu --key-file=node.pem -b

PLAY [Install git and wget] *****************************************************************************************************************************************************************

TASK [Gathering Facts] **********************************************************************************************************************************************************************
ok: [54.89.178.94]

TASK [Install git] **************************************************************************************************************************************************************************
ok: [54.89.178.94]

TASK [Install wget] *************************************************************************************************************************************************************************
ok: [54.89.178.94]

TASK [Execute the shell script] *************************************************************************************************************************************************************
changed: [54.89.178.94]

TASK [Print return information from the previous task] **************************************************************************************************************************************
ok: [54.89.178.94] => {
"msg": "Installed git wget "
}

TASK [Display script output] ****************************************************************************************************************************************************************
ok: [54.89.178.94] => {
"script_output.stdout_lines": [
"Filesystem Size Used Avail Use% Mounted on",
"/dev/root 29G 3.4G 26G 12% /",
"tmpfs 987M 160K 986M 1% /dev/shm",
"tmpfs 395M 1.2M 394M 1% /run",
"tmpfs 5.0M 0 5.0M 0% /run/lock",
"/dev/xvda15 105M 6.1M 99M 6% /boot/efi",
"tmpfs 198M 4.0K 198M 1% /run/user/1000"
]
}

PLAY RECAP **********************************************************************************************************************************************************************************
54.89.178.94 : ok=6 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

root@ip-172-31-87-83:~/uma#

root@ip-172-31-87-83:~/uma# cat gitget.yaml

name: Install git and wget hosts: web

tasks:

name: Install git ansible.builtin.apt: name: "git" state: present
name: Install wget ansible.builtin.apt: name: "wget" state: present
name: Execute the shell script
shell: /root/uma/myscript.sh
register: script_output
name: Print return information from the previous task
ansible.builtin.debug:
msg: "Installed git wget "
name: Display script output
debug:
var: script_output.stdout_lines
root@ip-172-31-87-83:~/uma#

DOCKER FAQ

Umashankar — Tue, 18 Jul 2023 01:06:23 +0000

What is Docker and why is it used?

Docker is an open-source platform that allows developers to automate the deployment and management of applications
within containers. Containers provide a lightweight and isolated environment to run applications and their dependencies consistently across different environments. It's used for having the Portability, Efficiency & less Cost.

What is a Docker image and how is it different from a Docker container?
Docker image is a read-only template or snapshot that contains the instructions for creating a Docker container. Its packaged and self-contained unit that includes everything needed to run an application.
Docker container is a running instance of a Docker image. It can be thought of as a lightweight, isolated, and executable environment
How do you create a Docker image and run a Docker container?
docker run -d --name container_name image_name
What is a Dockerfile and how do you use it to create a Docker image?
Dockerfile is a text file that contains a set of instructions used to build a Docker image.
docker build -t image_name
How can you inspect the contents of a Docker container and the changes made to a container while it was running?
docker exec -it container_name /bin/bash
docker inspect container_name
How can you share a Docker image with others and pull an image from a Docker registry?
To share the docker image, we need to push the image to a Docker registry. A Docker registry is a centralized repository where Docker images are stored and can be accessed by others. The most common Docker registry is Docker Hub.
docker push username/repository
docker pull username/repository
What are the different network modes available in Docker and how do you choose the right network mode for your application?
Docker provides different network modes to facilitate communication between containers and the host system or other containers. The available network modes are Bridge, Host, None,Overlay & Macvlan network modes.
Default bridge network mode for most applications that require container-to-container communication within a single host.
Host network mode when you need maximum network performance and don't require network isolation.
Overlay network mode for multi-host deployments or container orchestration using Docker Swarm.
None network mode when you want to run a container without network access or configure networking explicitly inside the container.
Macvlan network mode when containers need direct connectivity to the physical network, resembling separate physical devices.
How can you mount a volume in a Docker container and share data between the host and container?
Create volume using - docker volume create myvolume
Mount volume - docker run -v volume_name_or_path:container_path
Access volume - docker volume inspect myvolume
What is the difference between a Docker Compose file and a Dockerfile, and how are they used in deploying multi-container applications?
Docker Compose file and a Dockerfile serve different purposes in the deployment of multi-container applications.
A Dockerfile is a text file that contains instructions to build a Docker image. It provides a recipe for creating an image by specifying the base image, adding dependencies, copying files, setting environment variables, and defining commands to run. The Dockerfile defines the configuration and contents of a single container image.
Docker Compose file is a YAML file that defines and manages multiple containers as a single application. It allows you to describe the services, their relationships, networking, volumes, environment variables, and other configurations required for your multi-container application. Docker Compose simplifies the management of multiple containers, allowing you to start, stop, scale, and link them together.
How can you monitor the performance of a Docker container and diagnose issues with it?
Command used to monitor the peformance.
docker stats container_name displays real-time statistics about CPU usage, memory consumption, network I/O, and disk I/O for a specific container.
docker logs container_name command to view the logs of a specific container
APM Tools
Components of Docker and its Brief Summary
Docker is composed of several key components that work together to enable containerization and container management.
Docker Engine is the core runtime environment for containers.
Docker images are read-only templates or snapshots that contain the necessary files, dependencies, and configurations to run an application.
Docker containers are runnable instances of Docker images. Containers encapsulate an application and its dependencies, providing an isolated and consistent runtime environment.
Docker Registries are repositories that store and distribute Docker images. Docker Hub is the default public registry.
What is the differenet between docker pause and unpause?
These are used to temporarily pause and resume the execution of a running container, respectively.
Docker pause command is used to freeze the execution of a running container. When you pause a container, its processes are halted, and it enters a suspended state. The container's file system and memory state remain intact, but its CPU and system resources are no longer utilized.
docker pause container_name

Docker unpause command is used to resume the execution of a paused container. It reverses the effects of the docker pause command, allowing the container's processes to continue running. When you unpause a container, it returns to its normal operating state, and CPU and system resources are once again allocated to it
docker unpause container_name

What is the differenet between docker stop and kill? Docker stop command is used to gracefully stop a running container by sending a termination signal (SIGTERM) to the container's main process. docker stop container_name

Docker kill command is used to forcefully terminate a running container by sending a termination signal (SIGKILL) to the container's main process. When a container receives the SIGKILL signal, it is immediately terminated without any opportunity for cleanup or graceful shutdown

Docker stop provides a graceful way to stop a container, allowing it to clean up resources and shut down properly. It provides a chance for running processes to perform any necessary cleanup actions. On the other hand, docker kill forcefully terminates a container without giving it an opportunity to clean up. It is useful when immediate termination is required or when a container is unresponsive.

What is the differenet between docker exec and attach? Docker exec command is used to execute a command inside a running container. It allows you to run commands or scripts in an existing container, interacting with its environment and processes. When you use docker exec, a new process is started within the container, and you can specify the command to run as an argument. docker exec container_name command

Docker attach command is used to attach the host's standard input, output, and error streams to a running container. It connects the terminal or shell session to the container's main process, allowing you to see its output and interact with it directly. When you use docker attach, you connect to the main process of the container that was started when the container was launched
docker attach container_name

List of dockerfile instructions and its Brief Summary? Commonly used dockerfile instructions. FROM: Specifies the base image for your Docker image. It defines the starting point for building your image and can be an official image from Docker Hub or a custom image you've created.

MAINTAINER (deprecated): Specifies the name and email address of the image maintainer. This instruction is deprecated, and it's recommended to use the LABEL instruction instead to provide metadata about the image.

LABEL: Adds metadata to the Docker image. You can include information such as version, author, description, or any custom labels that are useful for identification and organization.

RUN: Executes a command during the build process. It allows you to run commands within the image, such as installing dependencies, configuring the environment, or running build scripts.

CMD: Specifies the default command to be executed when a container is started from the image. CMD can be overridden at runtime if a command is passed as an argument when starting the container.

ENTRYPOINT: Sets the primary command for the container. Unlike CMD, ENTRYPOINT doesn't allow overriding the command with arguments. It's often used to define the main executable for the containerized application.

USER: Sets the user or UID (user identifier) for subsequent instructions. It allows you to switch from the default root user to a non-root user within the image for improved security and best practices.

RUN (multi-line form): Executes multiple commands as a single instruction. It allows you to combine multiple commands into a single layer in the image, reducing the number of intermediate layers and optimizing the image size.

What is the differenet between CMD vs Entry CMD instruction sets the default command and parameters for the container. It specifies the command that should be executed when a container is run from the image. It allows you to define the main behavior of the container, such as the primary process that runs inside the container. The CMD instruction is typically used to provide default command-line arguments or parameters to the container's main process. It can be overridden by passing a command as an argument when running the container.

The ENTRYPOINT instruction sets the primary command for the container. It specifies the executable or script that should be executed when a container is run from the image. The ENTRYPOINT instruction is similar to CMD, but it does not allow the command to be overridden with additional arguments at runtime.

CMD specifies the default command and/or parameters for a container and can be overridden at runtime.
ENTRYPOINT sets the primary command for a container and does not allow the command to be overridden.

Terraform Code - OCI Instance

Umashankar — Mon, 17 Jul 2023 16:47:27 +0000

terraform {
oci = {
source = "oracle/oci"
version = "5.4.0"
}
}
}

Configure the Oracle Cloud provider

Resources

provider "oci" {
tenancy_ocid = "ocid1.tenancy.oc1..aaaaaaaa7uzhjutgya5yjptkgotowujccvsddes2jly2hohvkrvd6ctl7pna"
user_ocid = "ocid1.user.oc1..aaaaaaaabfoxa4e2nzck7k5f7foublichvn6ys4fqoviufna4v23yswus7gq"
fingerprint = "00:60:8d:87:1c:ec:fd:94:55:42:85:cb:8a:67:36:d6"
private_key_path = "C:\DevOps\Terraform-Project\oracleidentitycloudservice_usdba-07-15-13-28.pem"
region = "ap-mumbai-1"
disable_auto_retries = true
}

oci_provider_variables.auto.tfvars

Variables

tenancy_ocid = "ocid1.tenancy.oc1..aaaaaaaa7uzhjutgya5yjptkgotowujccvsddes2jly2hohvkrvd6ctl7pna"
user_ocid = "ocid1.user.oc1..aaaaaaaabfoxa4e2nzck7k5f7foublichvn6ys4fqoviufna4v23yswus7gq"
fingerprint = "00:60:8d:87:1c:ec:fd:94:55:42:85:cb:8a:67:36:d6"
private_key_path = "C:\DevOps\Terraform-Project\oracleidentitycloudservice_usdba-07-15-13-28.pem"
region = "ap-mumbai-1"
disable_auto_retries = true

Create a new compute instance

resource "oci_core_instance" "Harerama" {
compartment_id = "ocid1.tenancy.oc1..aaaaaaaa7uzhjutgya5yjptkgotowujccvsddes2jly2hohvkrvd6ctl7pna"
display_name = "Harekrishna-instance"
shape = "VM.Standard2.1"

}

Key files - oracleidentitycloudservice_usdba-07-15-13-28.pem

What is DevSecOps?

Umashankar — Thu, 13 Jul 2023 16:05:13 +0000

DevSecOps, Development, Security, and Operations is an approach to software development that integrates security best practices into every stage of the software development lifecycle (SDLC).

How DevOps and SRE are different?

Umashankar — Thu, 13 Jul 2023 16:02:42 +0000

The DevOps team takes care of the product or application development process with Continuous Integration/ Continuous Delivery to the business requirements. The SRE team uses software engineering principles to automate IT operations. The SRE team uses three Service Level Commitments to measure how well a system performs.

What are the list of DevOps Tools?

Umashankar — Thu, 13 Jul 2023 04:27:58 +0000

Version control - Git
CI/CD Tools - Jenkins
Containers - Dockers, Kubernetes
Monitoring Tools - Dynatrace, Datadog

What exactly do DevOps do?

Umashankar — Thu, 13 Jul 2023 04:25:28 +0000

The DevOps team does the software development and deployment process very efficiently, collaborating with teams working as one team, using Automation Tools, and Sharing knowledge.

What is DevOps in simple terms?

Umashankar — Thu, 13 Jul 2023 04:13:11 +0000

DevOps is a practice that aims to improve the collaboration between the development and operations teams in software development and deployment. Essentially, DevOps is a mindset that emphasizes working together in a more effective and cooperative manner.