<\/b>What’s inside Docker ?<\/li>\n<\/ol>\n <\/p>\n
Docker images.<\/b><\/p>\n
A Docker image is a read-only template. For example, an image could contain an Ubuntu operating system with Apache and your web application installed. Images are used to create Docker containers. Docker provides a simple way to build new images or update existing images, or you can download Docker images that other people have already created. Docker images are the build component of Docker.<\/p>\n
Docker registries.<\/b><\/p>\n
Docker registries hold images. These are public or private stores from which you upload or download images. The public Docker registry is called Docker Hub. It provides a huge collection of existing images for your use. These can be images you create yourself or you can use images that others have previously created. Docker registries are the distribution component of Docker.<\/p>\n
Docker containers.<\/b><\/p>\n
Docker containers are similar to a directory. A Docker container holds everything that is needed for an application to run. Each container is created from a Docker image. Docker containers can be run, started, stopped, moved, and deleted. Each container is an isolated and secure application platform. Docker containers are the run component of Docker.<\/p>\n
Exploring working.<\/b><\/p>\n
The docker container is created from read-only templates. Each image consists of a series of layers. Docker makes use of union file systems to combine these layers into a single image. Union file systems allow files and directories of separate file systems, known as branches, to be transparently overlaid, forming a single coherent file system. While creating a docker container we can either use templates which are downloaded already or directly pull while running it. There are wide variety of option which can be used while creating a container. The options like binding a port, defining interactive , tty, container name, Once created we can attach the docker container.<\/p>\n
The underlying technology<\/b><\/p>\n
Namespaces<\/b><\/p>\n
Docker takes advantage of a technology called namespaces to provide the isolated workspace we call the container. When you run a container, Docker creates a set of namespaces for that container.<\/p>\n
This provides a layer of isolation: each aspect of a container runs in its own namespace and does not have access outside it.<\/p>\n
Some of the namespaces that Docker uses are:<\/p>\n
The pid namespace: Used for process isolation (PID: Process ID).<\/p>\n
The net namespace: Used for managing network interfaces (NET: Networking).<\/p>\n
The ipc namespace: Used for managing access to IPC resources (IPC: InterProcess Communication).<\/p>\n
The mnt namespace: Used for managing mount-points (MNT: Mount).<\/p>\n
The uts namespace: Used for isolating kernel and version identifiers. (UTS: Unix Timesharing System).<\/p>\n
Control groups<\/b><\/p>\n
Docker also makes use of another technology called cgroups or control groups. A key to running applications in isolation is to have them only use the resources you want. This ensures containers are good multi-tenant citizens on a host. Control groups allow Docker to share available hardware resources to containers and, if required, set up limits and constraints. For example, limiting the memory available to a specific container.<\/p>\n
Union file systems<\/b><\/p>\n
Union file systems, or UnionFS, are file systems that operate by creating layers, making them very lightweight and fast. Docker uses union file systems to provide the building blocks for containers. Docker can make use of several union file system variants including: AUFS, btrfs, vfs, and DeviceMapper.<\/p>\n
Container format<\/b><\/p>\n
Docker combines these components into a wrapper we call a container format. The default container format is called libcontainer. Docker also supports traditional Linux containers using LXC. In the future, Docker may support other container formats, for example, by integrating with BSD Jails or Solaris Zones.<\/p>\n
Installation <\/b><\/p>\n
The docker can be installed using Yum on Centos and apt-get on Ubuntu. Just need to add corresponding sources\/repos.<\/p>\n
Managing docker<\/p>\n
We can start and stop the docker service using commands as follows.<\/p>\n
start docker<\/p>\n
stop docker<\/p>\n
The docker system is accessible only when the service is running.<\/p>\n
Docker Images<\/p>\n
Docker hub provides predefined images which can be used for creating containers.<\/p>\n
docker search <image_name> # search for an image from docker hub<\/p>\n
and docker pull <image_name> pull the image from docker hub<\/p>\n
Eg::<\/p>\n
docker search ubuntu<\/p>\n
docker pull ubuntu<\/p>\n
Note:<\/strong> Please read the description completely before downloading images. It is recommended to download images with high star count and ‘OK’ OFFICIAL status.<\/p>\nContainer Creation<\/p>\n
We can create a docker container as follows<\/p>\n
docker run -i -t –name <container_name> <image_name> <process\/tty><\/p>\n
# -i interactive<\/p>\n
# -t specify tty<\/p>\n
E.g. :: Creating a docker container with ubuntu image<\/b><\/p>\n
docker run -i -t –name testcontainer ubuntu \/bin\/bash<\/p>\n
This command will create a docker container with interactive mode. Use Ctrl+p+q to exit from the container without killing the process<\/p>\n
Port binding and Ip assignment.<\/p>\n
The ports actually bind to a specific port of the node server. The connections to a port to a corresponding IP in the node is routed to a specific port in the container. In this way the connections to the port of the node to the IP will be directed to the specific port on the container. We route port ranges between the docker container and an IP (provided the services in node server with the corresponding ports are listening only to the main IP address of the server.<\/p>\n
Format:: <\/strong><\/p>\ndocker run -i -t –name -p <IP>:<node_port>:<container_port> <container_name> <image_name> <process\/tty><\/p>\n
Note:: For all following examples, we use xxx.xxx.xxx.xxx and xxx.xxx.xxx.yyy as additional IPs in the docker node<\/p>\n
E.g. 1 ::<\/p>\n
docker run -i -t -p xxx.xxx.xxx.xxx:80:80 -p xxx.xxx.xxx.xxx:22:22 -p xxx.xxx.xxx.xxx:3307:3306 –name custom_name centos\/ssh \/bin\/bash<\/p>\n
Format<\/p>\n
IP:Node Port:Container Port<\/p>\n
xxx.xxx.xxx.xxx:80:80<\/p>\n
xxx.xxx.xxx.xxx:22:22<\/p>\n
xxx.xxx.xxx.xxx:3307:3306<\/p>\n
E.g. 2 ::<\/strong><\/p>\ndocker run -i -t -p xxx.xxx.xxx.yyy:20-50:20-50 –name portmap ubuntu \/bin\/bash<\/p>\n
This will map ports 20 to 50 between the docker container and the IP \u201a\u00c4\u00f2xxx.xxx.xxx.yyy\u201a\u00c4\u00f4<\/p>\n
\n- Miscellaneous<\/li>\n<\/ol>\n
docker images #: to list docker images<\/p>\n
docker save <image_name> > <backup_name>.tar # backup an image<\/p>\n
docker load -i <backup_name>.tar # load a saved image<\/p>\n
docker ps # to show running docker containers<\/p>\n
docker ps -a # to show all containers including stopped ones<\/p>\n
docker rm -f <container name> # to delete a container<\/p>\n
docker rmi <delete a image> # to delete a image<\/p>\n
docker start <container name> # to start container<\/p>\n
docker attach <id\/name> # to attach a docker session<\/p>\n
docker info # to get the information of docker server<\/p>\n
Source: https:\/\/www.docker.com\/<\/p>\n
Docker Tutorial Conclusion<\/b><\/p>\n
The docker is the fundamental building block of distributed container deployments. It simplifyes the process of packing of application along with its components, scaling becomes a simple process of spinning up or shutting down multiple instances of each component. The Docker provides us with feature of sharing and management of containers.<\/p>\n
While containerized applications provide the necessary process isolation and packaging to assist in deployment, there are many other components necessary to adequately manage and scale containers over a distributed cluster of hosts.<\/p>\n
Hope this docker tutorial helped you to get some basic ideas about docker. If you have any questions about this docker tutorial please let us know.<\/p>\n
Please share this docker tutorial knowledge.<\/p>\n
<\/p>\n
<\/div>\n