# Docker

Module-4: Docker Assignment

1. Explain the difference between Virtualization, Containerization and Microservices?
    
    **Virtualization:**
    
    * **Purpose:** Creates virtual machines (VMs) that act as independent computers with their own operating systems (OS).
        
    * **Isolation:** VMs are fully isolated from each other and the host hardware, ensuring security and resource allocation.
        
    * **Resources:** VMs are resource-intensive, requiring their own CPU, memory, disk space, and other resources.
        
    * **Use cases:** Hosting multiple operating systems on a single server, running legacy applications, isolating development environments.
        
    
    **Containerization:**
    
    * **Purpose:** Packages applications with all their dependencies and libraries into containers that share the host's operating system.
        
    * **Isolation:** Containers are isolated from each other using namespaces, cgroups, and other mechanisms, but share the underlying OS.
        
    * **Resources:** Containers are more lightweight than VMs, requiring fewer resources and booting faster.
        
    * **Use cases:** Deploying multiple applications on a single server, microservices architecture, continuous integration/continuous delivery (CI/CD) pipelines.
        
    
    **Microservices:**
    
    * **Purpose:** Breaks down applications into smaller, independent, and loosely coupled services.
        
    * **Focus:** Each microservice has its own functionality, codebase, deployment, and scaling process.
        
    * **Communication:** Microservices communicate through APIs, allowing independent development and deployment.
        
    * **Benefits:** Increased agility, scalability, and resilience.
        
    
    Here's a table summarizing the key differences:
    
    | **Feature** | **Virtualization** | **Containerization** | **Microservices** |
    | --- | --- | --- | --- |
    | **Purpose** | Create isolated virtual machines | Package applications with dependencies | Break down applications into smaller services |
    | **Isolation** | Full isolation of VMs and host hardware | Isolation of containers on shared OS | Independent microservices communicate through APIs |
    | **Resources** | Resource-intensive | More lightweight than VMs | Vary depending on the service |
    | **Use cases** | Multiple OS, legacy apps, development environments | Multiple applications, microservices, CI/CD | Increased agility, scalability, resilience |
    
    **Relationship between them:**
    
    * Virtualization can be used to create a platform for running containers or deploying microservices.
        
    * Containerization can be used to package and deploy microservices.
        
    * Microservices can be deployed on VMs or containers.
        
2. Define Docker Engine, Docker Image, Docker File, Docker Compose? Describe the lifecycle of Docker Container.
    
    **Docker Engine:**
    
    * A software platform that installs on your computer and manages Docker containers.
        
    * It provides the runtime environment and tools to build, run, and manage containers.
        
    * Docker Engine includes a daemon that listens for API requests and manages container creation, execution, and cleanup.
        
    
    **Docker Image:**
    
    * A read-only template used to create Docker containers.
        
    * It contains all the necessary dependencies and libraries needed to run an application.
        
    * Images are built using Dockerfiles, which specify the instructions for creating the image layer by layer.
        
    * Images are portable and can be shared and run on any system with Docker Engine installed.
        
    
    **Dockerfile:**
    
    * A text file containing instructions for building a Docker image.
        
    * Each line in the Dockerfile specifies a command that is executed when the image is built.
        
    * Dockerfiles include commands for installing software, setting environment variables, copying files, and running scripts.
        
    * Dockerfiles are used to create consistent and repeatable images that can be easily shared and deployed.
        
    
    **Docker Compose:**
    
    * A tool used to define and run multi-container applications.
        
    * It uses a YAML file to define the services, networks, and volumes for your application.
        
    * Compose allows you to start, stop, and manage all the containers in your application with a single command.
        
    * It simplifies the deployment and management of complex applications composed of multiple containers.
        
    
    **Docker Container Lifecycle:**
    
    1. **Image Pull:** The Docker Engine downloads the desired image from a registry (e.g., Docker Hub) if it's not already available locally.
        
    2. **Container Creation:** The Docker Engine unpacks the image and creates a container from its layers.
        
    3. **Container Start:** The Docker Engine starts the container's process and assigns resources (CPU, memory, etc.).
        
    4. **Running:** The application runs inside the container, isolated from the host system and other containers.
        
    5. **Stop/Pause:** The Docker Engine can stop or pause the container, allowing it to be restarted or resumed later.
        
    6. **Kill/Remove:** The Docker Engine can kill the container process and remove the container object.
        
    7. **Image Removal:** The Docker Engine can remove the image locally, freeing up disk space.
        
3. Explain the different Docker Components - Docker Client, Docker Host and Docker Registry.
    
    **Docker Components:**
    
    Docker consists of several components that work together to create, run, and manage containers. Here's a breakdown of the key components:
    
    **1\. Docker Client:**
    
    * **Function:** The user interface for Docker.
        
    * **Purpose:** Interacts with the Docker daemon through a REST API to send commands and receive responses.
        
    * **Location:** Typically installed on your local machine.
        
    * **Responsibilities:**
        
        * Building, running, stopping, and removing containers.
            
        * Pulling and pushing images to and from registries.
            
        * Managing networks, volumes, and other Docker resources.
            
    
    **2\. Docker Daemon:**
    
    * **Function:** The backend service that handles Docker commands and manages container operations.
        
    * **Purpose:** Listens for API requests from the Docker client and executes them.
        
    * **Location:** Runs on the same host as the Docker client or a remote host.
        
    * **Responsibilities:**
        
        * Creating and starting containers from Docker images.
            
        * Managing the lifecycle of containers (start, stop, kill, remove).
            
        * Maintaining the state of containers and their resources.
            
        * Communicating with Docker registries to pull and push images.
            
    
    **3\. Docker Registry:**
    
    * **Function:** A server that stores and distributes Docker images.
        
    * **Purpose:** Allows users to share and discover public and private Docker images.
        
    * **Types:**
        
        * **Public:** Open to anyone, most commonly used is Docker Hub.
            
        * **Private:** Hosted by organizations or individuals for internal use.
            
    * **Responsibilities:**
        
        * Storing and managing Docker images.
            
        * Providing access control for image sharing.
            
        * Performing security scans on uploaded images.
            
4. Explain with an example, about how you would push a local image to DockerHub and AWS ECR? (Complexity - Simple)
    
5. Explain the Docker file statements - COPY, ADD, CMD, RUN, ENTRYPOINT
    
    **COPY:**
    
    * **Function:** Copies files and directories from the host machine to the container's filesystem.
        
    * **Syntax:** `COPY <source> <destination>`
        
    * **Example:** `COPY . /app` copies all files and directories from the current directory to the `/app` directory inside the container.
        
    
    **2\. ADD:**
    
    * **Function:** Similar to COPY, but also supports extracting archives and remote URLs.
        
    * **Syntax:** `ADD <source> <destination>`
        
    * **Example:** `ADD` [`https://example.com/file.tar.gz`](https://example.com/file.tar.gz) `/app/` downloads the file, extracts it, and copies the extracted content to the `/app` directory.
        
    
    **3\. CMD:**
    
    * **Function:** Specifies the default command to execute when the container starts.
        
    * **Syntax:** `CMD ["executable", "parameter1", "parameter2"]` or `CMD command parameter1 parameter2`
        
    * **Example:** `CMD ["/bin/bash"]` starts the container with a bash shell.
        
    
    **4\. RUN:**
    
    * **Function:** Executes commands during the image build process.
        
    * **Syntax:** `RUN <command>`
        
    * **Example:** `RUN apt-get update && apt-get install -y nginx` installs the nginx package on the image.
        
    
    **5\. ENTRYPOINT:**
    
    * **Function:** Defines the main process that the container will run.
        
    * **Syntax:** `ENTRYPOINT ["executable", "parameter1", "parameter2"]` or `ENTRYPOINT command parameter1 parameter2`
        
    * **Example:** `ENTRYPOINT ["/usr/sbin/nginx"]` starts the nginx server when the container starts.
        
    
    **Key Differences:**
    
    * **CMD vs. ENTRYPOINT:**
        
        * ENTRYPOINT is executed first, and its arguments cannot be overridden when running the container.
            
        * CMD is used as a default command and can be overridden with arguments when running the container.
            
    * **COPY vs. ADD:**
        
        * COPY only copies files and directories.
            
        * ADD supports extracting archives and remote URLs.
            
6. Create a Docker Volume Container and attach it to two different nginx containers. (Complexity - Simple)
    
7. Create a Docker File for a Python based flask application. Execute the same using Jenkins Pipeline. You should have a :5000 flask webpage running. (Complexity - Medium)
    
8. Create and deploy Wordpress application using Docker Compose file. Create a Jenkins Job to execute your docker compose file and the output should show the ip-address of Wordpress application.(Complexity - Medium)
    
9. Create a Docker Multistage build for Python based application.
    
10. Explain the different Docker networking and the significance of each mode.
    
    **Docker Networking Modes and their Significance:**
    
    Docker offers various networking modes to configure how containers interact with the network and each other. Choosing the appropriate mode depends on your specific needs and application requirements.
    
    Here's a breakdown of the different Docker networking modes and their significance:
    
    **1\. Bridge (default):**
    
    * **Function:** Creates a virtual bridge network that connects the containers to each other and the host network.
        
    * **Significance:**
        
        * Provides isolation between containers and the host network.
            
        * Allows containers to communicate with each other through DNS names or IP addresses.
            
        * Offers a good balance between isolation and connectivity for most applications.
            
    
    **2\. Host:**
    
    * **Function:** Shares the host's network namespace with the container.
        
    * **Significance:**
        
        * Provides the container with the same network identity as the host.
            
        * Enables direct access to host resources like network interfaces and ports.
            
        * Useful for applications requiring full access to the host network, but not recommended for production environments due to security implications.
            
    
    **3\. None:**
    
    * **Function:** Disables the network stack for the container.
        
    * **Significance:**
        
        * Creates isolated containers with no access to the network.
            
        * Useful for debugging purposes or when network access is not required.
            
    
    **4\. Overlay:**
    
    * **Function:** Creates a virtual network that spans multiple Docker hosts.
        
    * **Significance:**
        
        * Enables communication between containers across different hosts in a Docker swarm.
            
        * Offers scalability and fault tolerance for distributed applications.
            
    
    **5\. Macvlan:**
    
    * **Function:** Assigns a dedicated MAC address and IP address from the host's network to the container.
        
    * **Significance:**
        
        * Provides finer-grained control over the container's network configuration.
            
        * Useful for integrating containers with existing network infrastructure.
            
    
    **6\. Custom Bridge:**
    
    * **Function:** Allows creating custom bridge networks with specific configurations.
        
    * **Significance:**
        
        * Enables fine-tuning network settings like DNS servers, IP ranges, and subnet masks.
            
        * Useful for advanced network configurations and specific application requirements.
