I recently started using Docker and am very impressed with how easily you can set up environment to develop, test and deploy applications. It provides a virtualization environment, but unlike some of the other virtualization solution, Docker container\u00a0\u00a0(runtime environment for your application) \u00a0is a process instead of a\u00a0complete OS. It runs natively on Linux and uses a single virtual machine on Windows and Mac in which Docker containers run.<\/p>\n
Using Docker you can easily create containers required for your application to run, for example containers for database, application server etc and easily deploy them to test or production environment. You can create images of your set-up and re-create the same setup constantly from those images. When you create a Docker image, it has to be based on some variant of Linux base image.\u00a0You can browse Docker images at\u00a0Docker Hub<\/a>.<\/p>\n This post is not meant to be tutorial or\u00a0detailed information about Docker. You can refer\u00a0to Docker web site<\/a> for that. As many of my other posts, this post is meant to be reference for me – about\u00a0some of the Docker commands I have used so far.<\/p>\n You create Dockerfile to create a new docker container. Some of the commands used in the Dockerfile are (also see complete official reference docs<\/a>) \u00a0–<\/p>\n FROM<\/strong> – Specify base image for your docker image. For example –\u00a0FROM ubuntu<\/p>\n ADD<\/strong> – Add file(s) from the host machine to a docker container. For example, to copy setup.sh file, from the directory from where docker commands are run, to my container – ADD .\/setup.sh \/setup.sh<\/p>\n RUN<\/strong> – Runs a command in the container. For example to make setup.sh file executable after copying to the container – RUN chmod +x \/setup.sh<\/p>\n <\/p>\n (See complete reference<\/a>)<\/p>\n The above command will create a docker container from base ubuntu image, name it my-ubuntu, run bash command (open bash shell) and keep standard input open (-i) and text input console open (-t, together -it). It will open a bash shell in the container, where\u00a0you can execute any command.<\/p>\n Run above command from the directory where Dockerfile is present. -t option specifies name of the image in : format. See build command reference\u00a0<\/a>for details.<\/p>\n If you run this command from another terminal on the host computer\u00a0(from where you are running docker commands), you will see my-ubuntu container created above. If you did not exit the bash shell opened in that container (exit command), then you should see my-ubuntu container listed. If you exit the shell, the container stops (because bash was the main command and it terminated). To see all containers, including stopped ones, use -a flag<\/p>\n ps command shows lot of information. However you can filter and format the output. Format should be a Go template string. For example to see only names of \u00a0container use following command –<\/p>\n See docs<\/a>\u00a0for more formatting options.<\/p>\n Above command will start my-ubuntu container, if it was stopped. It will use the same entrypoint command that was specified when the container was created. In this case it will open bash shell, but will terminate immediately. So the container would also stop. Specifying -i option will keep stdin open and will allow you to run commands in the container.<\/p>\n use stop command\u00a0to stop the container, e.g. docker stop my-ubuntu1<\/p>\n To remove a container , use rm command\u00a0(you can specify multiple containers names) –<\/p>\n If you want to remove running container, use -f option, e.g. docker rm -f my-ubuntu1. Instead of container names, you can use container ids also.<\/p>\n Attaching to running container<\/p>\n Let’s create a container in detached mode.<\/p>\n -d option runs docker container in background (detached mode). You will immediately return to command prompt after executing the above command.<\/p>\n To attach to the \u00a0the above container and the process that started it (in this case \/bin\/bash) –<\/p>\n This will allow you to execute commands in bash shell that was started in the container when container was run. Existing the shell (exit command) will also terminate the container.<\/p>\n If you do not want to terminate the container upon existing the bash shell, you can use exec command. It can be used to run any command, not just bash shell.<\/p>\n This will open a new bash shell. Exiting that shell will not terminate the container because it was not the command that started the container.<\/p>\n To list all images –<\/p>\n To remove images, use rmi command. Note that there should be no container based on the images you want to delete. If there are containers using images to be deleted, then remove those containers first using rm command mentioned above.<\/p>\n Instead of names you can also use image ids.<\/p>\n Following command will delete ALL containers, so be careful<\/p>\n -q option tells ps command to return only ids, which are then fed to rm command.<\/p>\n Here is an example of using filters to remove containers (this example removes all containers starting with my-ubuntu)<\/p>\n Following command deletes all images, so again be careful –<\/p>\n To delete by filtering on image name –<\/p>\n As mentioned earlier, volumes can be used to share data between host and container and also amongst containers. Let’s create a container, call it container1, with volume v-container1.<\/p>\n You can open a bash shell in container and verify that \/v-container1 folder is available. Create a file in this folder.<\/p>\n Now create a container, container2, that uses volumes from container1.<\/p>\n Note that the above command uses –rm to create a temporary container. Once the main application started in the container (in this case bash shell) stops, the container will be terminated and it won’t appear in ‘docker ps -a’ command too.<\/p>\n Once the shell opens in container2, you can ensure that \/v-container1 is available and the file we created exists in the folder.<\/p>\n To share folder from the host to a container, use the same -v option, but specify <host-folder-name>:<path-in-container> argument. For example if you want make, say \/project1\/src folder from host map to \/src folder in the container –<\/p>\n ${PWD} tells docker to map present working directory. We could have entered the entire path too – docker run –rm -it -v \/project1\/src:\/src ubuntu<\/p>\n If your host is Mac or Windows, make sure \/project1\/src folder is shared in Docker preferences, else docker will throw error.<\/p>\n I found docker volumes very useful when backing up data from one container and restoring it in another. For example, if you had created a container from mysql image and populated a database, you could easily create a tar file of that data from the host machine and then restore it when you create a new instance of the container, or restore the data in the original db container. However you will need to know volumes used by the container – \u00a0in this case the container using mysql base image. You can find that easily by running this command –<\/p>\n Note that the the output is JSON. Look for “Mounts” key and “destination” sub-key in that.\u00a0In case of mysql container, this value is “\/var\/lib\/mysql”. This is where the data is stored in mysql container. So we can use -volumes-from option we saw above to use this volume in another container and then run tar command on it and save it in the volume mapped on the host machine.<\/p>\n We are using –rm because we want to create a temporary container. The container will be terminated after the command is finished. We are using volumes from my-db container, which is based on mysql image. This makes \/var\/lib\/mysql folder available to this (temporary) container. Then we are mapping backup-data folder in the present folder (on host machine) to \/backup-data in the container. So now the temporary container has access to \/var\/lib\/mysql (from my-db container) and backup-data folder on the host machine. Then we execute tar command to create my-db-volume.tar in \/backup-data, which in effect creates in the same named folder in the host machine. And it tars data from \/var\/lib\/mysql, which is contains data from my-db container.<\/p>\n To restore the data –<\/p>\n Here we are restoring the data into newly created my-new-db container (created with mysql base image). We are using volumes from the new db container, so \/var\/lib\/mysql folder is available to the temporary container. We map the same folder from host to the temp container and then run tar command to untar\u00a0\/backup-data\/my-db-data.tar (which in untars the same named file from the host machine) into root. So data from \/var\/lib\/mysql in the tar file will be written to \/var\/lib\/mysql in the temp container. And since this volume is coming from my-new-db (the container into which we want to restore the data), we get data saved in that container.<\/p>\n Let say you create a container from some base image, you installed more applications in that container. Now you want to save the container as an image so that next time you could create a container from that image and don’t have to repeat installation of all the additional applications. You can do that with export command –<\/p>\n Specify output file path using -o option. The last argument is name of the container from which you want to create an image.<\/p>\n To create image\u00a0from the exported file, use import command –<\/p>\n The above command will create image named container1-image from container1-image.tar file.<\/p>\n I know the post is getting really long, but I wanted to put some of the most useful commands, according to me, \u00a0of Docker in this post. I would wrap up the post by briefly list some of the useful commands in docker-compose<\/p>\n Docker-compose <\/a>can be used to configure multiple docker containers in the same file and also to specify dependencies between them. There is a docker-compose command which executes commands from docker-compose-yml <\/a>(though you can override file name in docker-compose command).<\/p>\n Structure of docker-compose.yml is simple – It has version umber at the top (the latest version is 3, but I have mostly worked with version 2), and then there is services section which lists container definitions. Here an example of docker-compose.yml<\/p>\n Many of the options we have already seen in this post so far, so I though I would just show and example of docker-compose.yml. The file contains definition of one db container that specifies image directly in the docker-compose.yml and one app server container that builds the container from dockerfile in ..\/my-app-server folder. Note the dependency of app server on db server, specified in\u00a0‘depends_on’ \u00a0section in the app server<\/p>\n To bring up both the container, run<\/p>\n To run docker-compose in detached mode, use -d option. However you may want to use non-detached mode to see output messages.<\/p>\n To stop all containers started in docker-compose.yml, press CTRL+C if it is running in foreground, or you can run<\/p>\n -Ram Kulkarni<\/p>\n Update:<\/strong> \u00a0I had run into a networking issue in docker containers on Linux. The containers created did not have access to internet. After struggling to find a solution for this issue, I realized that the issue could be with DNS lookup. I am not sure if this is a generic problem, but in my setup DNS were not set properly in the containers. So I had to specify DNS (find DNS from host network settings) when creating containers, either in docker-compose.yml (see this<\/a>) or when executing ‘docker run’ command (see this<\/a>).<\/p>\n","protected":false},"excerpt":{"rendered":" I recently started using Docker and am very impressed with how easily you can set up environment to develop, test and deploy applications. It provides a virtualization environment, but unlike some of the other virtualization solution, Docker container\u00a0\u00a0(runtime environment for your application) \u00a0is a process instead of a\u00a0complete OS. It runs natively on Linux and … <\/p>\nHow to get Docker<\/h1>\n
\n
Dockerfile<\/h1>\n
Creating Docker images and containers<\/h1>\n
Create docker container with command line options<\/h2>\n
Create a container from ubuntu image<\/h3>\n
$ docker run -<\/span>name my-<\/span>ubuntu -<\/span>it ubuntu bash\r\n<\/pre>\nCreate an image from Dockerfile<\/h3>\n
$ docker build -t image_name .\r\n<\/pre>\n
See currently running containers<\/h2>\n
$ docker ps\r\n<\/pre>\n
$ docker ps -<\/span>a\r\n<\/pre>\n$ docker ps -<\/span>-<\/span>format \"<\/span>{{.Names}}<\/span>\"<\/span>\r\n<\/pre>\nStart Container<\/h3>\n
$ docker start my-<\/span>ubuntu\r\n<\/pre>\n$ docker start -<\/span>i my-<\/span>ubuntu\r\n<\/pre>\n$ docker rm my-<\/span>ubuntu1 my-ubuntu\r\n<\/pre>\n$ docker run -<\/span>d -it -<\/span>-<\/span>name my-<\/span>ubuntu ubuntu\r\n<\/pre>\n$ docker attach my-<\/span>ubuntu\r\n<\/pre>\n$ docker exec -<\/span>it my-<\/span>ubuntu bash\r\n<\/pre>\nListing images<\/h2>\n
$ docker images\r\n<\/pre>\n
Deleting Image<\/h2>\n
$ docker rmi my-<\/span>image1 my-<\/span>image2\r\n<\/pre>\nDelete all\u00a0Containers<\/h2>\n
$ docker rm $(<\/span>docker ps -<\/span>a -<\/span>q)<\/span>\r\n<\/pre>\n$ docker rm $(<\/span>docker ps -<\/span>-<\/span>filter name=<\/span>my-<\/span>ubuntu*<\/span> -<\/span>q)<\/span>\r\n<\/pre>\nDelete all Images<\/h2>\n
$ docker rmi $(<\/span>docker images -<\/span>q)<\/span>\r\n<\/pre>\n$ docker rmi (<\/span>$docker images *<\/span>my-<\/span>ubuntu*<\/span>)<\/span>\r\n<\/pre>\nUsing Volumes<\/h2>\n
$ docker run -<\/span>dt -<\/span>-<\/span>name container1 -<\/span>v \/<\/span>v-<\/span>container1 ubuntu\r\n<\/pre>\n$ docker exec -<\/span>it container1 bash\r\n$ touch v-<\/span>container1\/<\/span>file-<\/span>in-<\/span>container1\r\n<\/pre>\n$ docker run -<\/span>-<\/span>rm -<\/span>it -<\/span>-<\/span>name container2 -<\/span>-<\/span>volumes-<\/span>from container1 ubuntu\r\n<\/pre>\nMapping folder from host to container<\/h2>\n
$ docker run -<\/span>-<\/span>rm -<\/span>it -<\/span>v ${<\/span>PWD}<\/span>:<\/span>\/<\/span>src ubuntu\r\n<\/pre>\nUsing volumes for backup and restore<\/h2>\n
$ docker inspect my-db\r\n<\/pre>\n
$ docker run <\/span>-<\/span>-<\/span>rm <\/span>-<\/span>-<\/span>volumes<\/span>-<\/span>from my<\/span>-<\/span>db <\/span>-<\/span>v $<\/span>{<\/span>pwd<\/span>}<\/span>\/<\/span>backup<\/span>-<\/span>data<\/span>:<\/span>\/<\/span>backup<\/span>-<\/span>data ubuntu tar cvf <\/span>\/<\/span>backup<\/span>-<\/span>data<\/span>\/<\/span>my<\/span>-<\/span>db<\/span>-<\/span>volume<\/span>.<\/span>tar <\/span>\/<\/span>var<\/span>\/<\/span>lib<\/span>\/<\/span>mysql\r\n<\/span><\/pre>\n$ docker run -<\/span>-<\/span>rm -<\/span>-<\/span>volumes-<\/span>from my-<\/span>new-<\/span>db -<\/span>v $(<\/span>pwd)<\/span>\/<\/span>data-<\/span>backup:<\/span>\/<\/span>backup-<\/span>data ubuntu bash -<\/span>c \"<\/span>cd \/ && tar xvf \/backup-data\/my-db-data.tar<\/span>\"<\/span>\r\n<\/pre>\nCreating image from container<\/h2>\n
$ docker export<\/span> -<\/span>o \/<\/span>my-<\/span>images\/<\/span>container1-<\/span>image.tar container1\r\n<\/pre>\n$ docker import<\/span> \/<\/span>my-<\/span>images\/<\/span>container1-<\/span>image.<\/span>tar container1-<\/span>image\r\n<\/pre>\nDocker-Compose<\/h2>\n
version: \"2\"\r\n\r\nservices: \r\n my-db:\r\n image: mysql\r\n environment:\r\n MYSQL_DATABASE: my-db\r\n container_name: my-db\r\n ports:\r\n - '3307:3306'\r\n\r\n my-app-server:\r\n build: ..\/my-app-server\r\n container_name: my-app-server\r\n stdin_open: true\r\n tty: true\r\n ports:\r\n - '8082:8080'\r\n - '9001:9001' # Open port for debuggin\r\n volumes: \r\n - ..\/src\/app1:\/src\/app1\r\n - ..\/logs:\/logs\r\n depends_on: \r\n - my-db\r\n<\/pre>\n
$ docker-compose up\r\n<\/pre>\n
$ docker-compose down\r\n<\/pre>\n