Introduction to Docker



What is Docker?

  • Docker is an open-source platform that allows developers to build, package, and deploy applications as containers while ensuring that they run consistently across different environments,

  • Containers are lightweight and efficient units of software that bundle together all the necessary code, libraries, and dependencies required to run an application.

  • Docker works by isolating an application and its dependencies into a container, which can then be run on any machine that has the Docker platform installed. 

  • Docker containers are isolated from each other and from the host system, which helps to prevent conflicts between applications and ensures that the application runs consistently regardless of the underlying system.

  • Docker uses a client-server architecture and comprises several components, including the Docker engine, Docker CLI, and Docker Hub,

  • The Docker engine is responsible for building, running, and managing containers,

  • Docker CLI provides a command-line interface for interacting with the Docker engine,

  • Docker Hub is a cloud-based registry that allows developers to store and share container images, which can be used to quickly deploy applications to production environments,

 

Difference between Docker Containers and Virtual Machines?

VM:

  • VM is a complete operating system that runs on top of a virtualization layer, such as VMware or VirtualBox, that emulates the underlying hardware.
     
  • Each VM runs its own guest operating system and applications, which are isolated from other VMs running on the same host.

Container:
  • Docker containers are a lightweight alternative to VMs that allow applications to run in an isolated environment without the overhead of a full OS.

  • A Docker container consists of an application and its dependencies bundled together, which can be run in any environment that supports Docker. 

  • Docker containers share the host operating system kernel, which makes them much more lightweight than VMs, and they can be started and stopped much faster.


Size and speed: Docker containers are much smaller in size and start up much faster than VMs since they don't have to boot up an entire operating system.

Resource usage: VMs require more resources to run since each VM must have its own guest operating system, whereas Docker containers share the host operating system's resources.

Isolation: Both technologies provide isolation, but Docker containers are considered to be less isolated than VMs because they share the host's kernel.

Portability: Docker containers can be easily moved between different hosts and environments, making them more portable than VMs.







  • A Docker image is a snapshot of an application and its dependencies at a specific point in time which includes everything needed to run an application, including the application code, libraries, and runtime environment.
  • Docker images are built from Dockerfiles, which are text files that specify the instructions to build the image.

  • A Docker container is a running instance of a Docker image that runs on top of the host operating system, sharing the kernel with other containers.





VOLUME instruction is used to create a mount point for a named volume or host directory that can be shared between the host and the container.


FROM ubuntu:latest

# Create a volume mount point
VOLUME /mydata

# Add instructions to the image...

Any data stored in /mydata inside the container will be stored outside the container on the host machine.

You can use the docker run command with the -v option to mount a volume to the container at runtime. For example:

docker run -v /path/on/host:/mydata my-image

This command mounts the /path/on/host directory on the host machine to the /mydata directory inside the container.

Note that if you do not specify a specific host path to mount to the volume when running the container, Docker will create a new anonymous volume and mount it to the specified path inside the container. 



Dockerfile à (docker build cmd) à Docker Image à (docker run cmd) à Docker Container à (docker push cmd) à ACR (Azure Container Registry)

Dockerfile: Use to create and build docker images
Docker compose file: Use to run the docker container based on settings described in docker-compose.yml

docker-run vs docker-compose: Both are used for running docker containers.
docker run is entirely command line based, which is used to start only 1 container where as docker-compose reads configuration data from a .yml file and can run multiple containers.

E.g.

docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=yourStrong(!)Password" -p 1433:1433 -d mcr.microsoft.com/mssql/server:2019-latest

docker-compose.yml:

version: "3.9"

services:

    sql-server-db:

    image: enternalsregistry.azurecr.io/sqlrestoredb:2019-latest

    container_name: sqlrestoredb_container

    ports:

      - "1455:1433"

    environment:

      SA_PASSWORD: "Hexagon@1"

      ACCEPT_EULA: "Y"


Commands:

Ø  docker build -t <ImageNameTobeCreated>:<tag> .
E.g.:
docker build -t Calcultor:Client .

Ø  docker images {list all the images}

Ø  docker run –name <container_name> -p 1433:1433 <image_name>:<tag>
{by default, latest tag will be used if you missed tagging}
{run command will look if you already have the image then it will run the container, otherwise it will pull the image from docker-hub and then run the container}
{-rm, we can use run command with -rm to run the container and remove it}
{-d, used to run in detached mode}

E.g:
docker run -e "ACCEPT_EULA=Y" -e "MSSQL_SA_PASSWORD=yourStrong(!)Password" -p 1433:1433 -d mcr.microsoft.com/mssql/server:2019-latest

docker run -i <image_name>:<tag> {to run the container in interactive way}

Ø  docker inspect <container_name Or initials> {detailed information of the container}

Ø  docker logs <container_name Or initials> {what data is printing on interactive terminal mode}

Ø  docker stats <container_name Or initials> {statistics of container}

Ø  docker ps {list all running active containers}

Ø  docker ps -a {list all active & inactive containers}

Ø  docker stop <container_name> {stop the container}
Or,
docker stop <initials> {initials means some difference b/w containers, like 3 letters of Container ID}

Ø  docker start <container_name> {start the inactive container}
Or,
docker start <initials>

Ø  docker rm <container_name Or initials> {remove only stop container}

Ø  docker rm <container_name Or initials> -f {forcefully remove running container}

Ø  Remove all the active/inactive containers at one go:
docker rm $(docker ps -a -q) -f

Ø  docker rmi <image_name> {remove image having inactive containers}

Ø  Remove all the images at one go:
docker rmi $(docker images -q) {remove image having inactive containers, otherwise use -f at last}

Ø  docker pull <image_name>:<tag> {use to pull the image from docker hub, ACR, ..}

Ø  Verifying Files uploaded in docker container:
docker exec -it <container_name Or initials> /bin/sh


Dockerfile:





E.g 1:

FROM mcr.microsoft.com/dotnet/framework/runtime:4.8-windowsservercore-ltsc2019 AS build-env

WORKDIR /app

COPY  ./bin/ .

ENTRYPOINT ["C:\\app\\Add.Client.exe"]

Note: AS <alias_name>: used in later stage, generally we use this in multistage builds


E.g 2:

FROM mcr.microsoft.com/mssql/server:2019-latest

ENV SA_PASSWORD=Hexagon@1

# USER mssql

# Copy the existing database backup file to the docker image directory 

COPY ./TestDB.bak /var/opt/mssql/backup/

# Launch SQL Server, confirm startup is complete, restore the database, then terminate SQL Server.

RUN ( /opt/mssql/bin/sqlservr --accept-eula & ) | grep -q "Service Broker manager has started" \

    && /opt/mssql-tools/bin/sqlcmd -S localhost -U SA -P $SA_PASSWORD -Q 'RESTORE DATABASE TestDB FROM DISK = "/var/opt/mssql/backup/TestDB.bak" WITH MOVE "TestDB" to "/var/opt/mssql/data/TestDB.mdf", MOVE "TestDB_Log" to "/var/opt/mssql/data/TestDB_log.ldf", NOUNLOAD, STATS = 5' \

    && pkill sqlservr


 Docker-Compose.yml

  1. docker-compose up: Build and start the containers defined in your docker-compose.yml file.
    docker-compose up -d: Start the containers in the background (detached mode).

  2. docker-compose down: Stop and remove the containers defined in your docker-compose.yml file.

  3. docker-compose stop: Stop the containers defined in your docker-compose.yml file.

  4. docker-compose start: Start the containers defined in your docker-compose.yml file.

  5. docker-compose restart: Restart the containers defined in your docker-compose.yml file.

  6. docker-compose ps: List the status of the containers defined in your docker-compose.yml file.

  7. docker-compose logs: View the logs of the containers defined in your docker-compose.yml file.

  8. docker-compose build: Build the images for the containers defined in your docker-compose.yml file.

  9. docker-compose up --build: Force a rebuild of the containers before starting them.

  10. docker-compose push: Push the images for the containers defined in your docker-compose.yml file to a Docker registry.

  11. docker-compose pull: Pull the images for the containers defined in your docker-compose.yml file from a Docker registry.

  12. docker-compose rm: Remove the containers defined in your docker-compose.yml file.

There are other commands available.

Note: 
The difference between docker push and docker-compose push is that docker push is used to push a single image, while docker-compose push is used to push multiple images at the same time.

Additionally, docker push requires you to specify the image name and tag, while docker-compose push automatically uses the image tags defined in your docker-compose.yml file.


Docker Registry:

Default Registry: Docker Hub

Push images to ACR:

  1. Create Container Registry and enable Admin user from the Access Keys to use in Azure DevOps pipelines,

  2. Pull/Create your docker image,

  3. Login to ACR:
    docker login <sever_name_ACR> -u <user_name> -p <password> {login to ACR} 

  4. Before pushing to ACR (or DockerHub), we have to tag our image w.r.t our Container Registry.

     docker tag <image_name_including_tag> <server_name_ACR>/<image_name_including_tag>

  5. Push the docker image to ACR

    docker push <tagged_image_name>

Docker commit:
  • Process of creating a new image from the current state of a container,
  • When you make changes to a running container, those changes are only saved within the container's storage layer and are not saved as part of the container image itself,
  • However, by using the "docker commit" command, you can create a new image that includes those changes, making it easy to create a new container that starts with those changes already applied.

    docker commit <container's name or ID> my-new-image
  • After running this command, you can use the new image to create new containers that include the changes made to the original container.

    Note: committing a container creates a new image that includes all of the changes made to that container, including any new files, modifications to existing files, and changes to the container's configuration.

More have to go :)

Docker comes in 3 network types:









Docker Orchestration:

Docker Swarm:
 





Popular posts from this blog

SOLID Principles

Image
Introduced by Robert C.Martin , known as Uncle Bob A set of principles that must be followed to develop flexible, maintainable, and scalable software systems Helps in reducing ' Tight Coupling ': A group of classes is highly dependent on one another. Loosely coupled classes minimize code changes, making code more reusable, maintainable, and flexible. Single Responsibility Principle One class = One responsibility One class = One reason to change Problem: The Program  class violates the SRP as it handles three separate responsibilities: Main() , CalculateArea() , and Print() . Rectification: Open-Closed Principle Class must  open for extension , but closed for modification Problem:  When creating a new shape, such as a rectangle, calling CalculateArea() and Print() requires passing a rectangle parameter, but the current design does not allow it. Rectification:  Therefore, we need to extend the CalculateArea and Printer classes without modifying their existing meth...
Read more

Nuget package | Pushing it to Azure Artifacts

Image
NuGet is a package management tool for .NET development that makes it easy to create, share, and consume packages . NuGet pack:   used to create a NuGet package from the files in a project,  will create a .nupkg file that contains the compiled output of the project along with any dependencies that are required for the package to work correctly.  Note: We can customize the package metadata by including a .nuspec file in our project or by passing in arguments to the Nuget Pack command. NuGet push:   used to publish a NuGet package to a NuGet server.  NuGet will upload the .nupkg file to the specified NuGet server. Note:  We'll need to provide authentication credentials for the server in order to push a package. Here's an example of how we might use nuget pack and nuget push : Navigate to the directory that contains the project we want to package (.csproj). Run nuget pack to create a .nupkg file for the project, nuget pack MyProject.csproj If we want to c...
Read more

WiX - Windows Installer XML

Image
Many ways of generating MSI packages for Windows applications. E.g: Vdproj, WiX ·         WIX:  Windows Installer XML ·         Free software toolset ·         XML code structure ·         Supports command-line interface to be integrated into any automated application build process or CI environment. ·         Developed by Microsoft, using this to develop installation packages for all their major products, including Office and Visual Studio Bundle ·         Bundles are often used to install prerequisites, such as the .NET Framework or C++ Run Time ·         Bundles also allow very large applications to be broken into smaller, logical installation packages that are chained together while still presenting a single product to the end-user. WiX Component The W...
Read more

Working with Git

Image
Git States Basic Git Commands git remote -v [shows the remote repository URLs linked to your local repo] git clone "<repository_url>" git add . [add all new and modified files (excluding deleted files)] OR, git add -A [add all changes, including deleted files] git add <file> [add specific file] git status [shows the status of your working directory (tracked/untracked/staged changes)] git commit -m "Commit message here" git log [displays commit history (press q to quit log view)] git push Working with Branches git branch [shows local branches] git branch -r [shows remote branches] git branch -a [shows both local and remote branches] git branch  devfeaturebranch git checkout  devfeaturebranch OR, git checkout -b devfeaturebranch [create & switch] git push -u origin devfeaturebranch [first-time push when the branch is not present in the remote] OR, git push [for subsequent pushes] git branch -d featurebranch [delete locally, use -D for forcefully delet...
Read more

C# Memory Tricks: Learn How To Master The Garbage Collector

Image
Introduction to .NET memory management Heap: Whenever an object/variable is created using the new keyword, it's stored in the Heap section of memory. How to release the Heap memory? In some languages such as C++, we have the "delete" keyword to free dynamically allocated memory on the heap. But in the.NET Framework, we don't have such. Here we have the Garbage collector which continuously deletes objects that is no longer used for our code. But why has Microsoft did not implement the "delete" keyword? Disadvantages of Garbage collection Fundamentals of the .NET Framework The Stack: Block of memory that is used for calling methods and storing local variables. The Heap:  Value type:  If we have local variables of value type they will store in Stack along with value and type, like this:- int a  = 1234; int b = 0; ----------------- int b = a; Reference type:  Type of variable that refers to the value stored on the heap. Boxing and Unboxing: A detailed look at ...
Read more

gRPC - Protobuf / Protocol Buffers

Image
  Overview: Protobuf / Protocol Buffers   –  an interface definition language or interface description language ( IDL ). Protobuf is a great way for schema definition and auto-generating source code. It ensures type safety, faster serialization, and deserialization.  SOAP - XML REST - JSON gRPC - Protocol Buffer Problems With JSON: No strict schema enforcement. People can easily change the structure to break the contract and it can cause confusion among the team members. // team 1 expectation { "order_id" : 1234 } // team 2 understanding { "orderId" : 1234 } // team 3 understanding { "order" : { "id" : 1234 } } Copy JSON is text-based. Human-friendly but not machine friendly. It takes time to serialize and deserialize when we use it for microservices communication. Protobuf/ Protocol Buffers : Protobuf  is Google’s  language-neutral ,  platform-neutral  method for deserializing & serializing  s...
Read more

Custom Azure DevOps pipeline task extension

Image
Pre-requisites/Dependencies 1.         Azure DevOps Organization with project 2.         Node.js (ver 10.x or higher) & NPM ·         Node.js is required to run the Azure DevOps CLI tools. Installing Node.js will also install NPM (Node Package Manager), which is used to install other dependencies. ·         Download:  Here (accept the default options in the setup wizard)   3.         TFX CLI (Azure DevOps Extension Tool) ·         TFX CLI is used to create, package, and publish Azure DevOps extensions. ·         Install via NPM (use any terminal): npm install -g tfx-cli 4.         Visual Studio Code ·         Visual Studi...
Read more

C# Questions Part 1

Image
  1.  What is a class? A class is a template to create an object. It contains properties as well as methods. Whereas an  Object is a real-time entity, consisting of state (look & feel) and behavior (what it does) 1 2 3 4 5 6 7 8 9 10 11 12 public class Student {    //data members    public int rollNumber { get ; set ; }    public string fullName { get ; set ; }      //method    public void PrintDetails ( )    {        //code of method    } } 2.  What are the main concepts of OOPs? Encapsulation, abstraction, polymorphism,  and  inheritance  are the main concepts of object-oriented programming. 3. Explain Encapsulation Encapsulation  is a  process of wrapping functions  and data members together in a class. It is like a  capsule , a single unit. Encapsulation is to prevent the unauthorized or unwanted chang...
Read more