Docker is an open source containerization platform. It enables developers to package applications into containers—standardized executable components combining application source code with the operating system (OS) libraries and dependencies required to run that code in any environment. As Docker reduces the need for more infrastructure resources for development and the container created for individual processes can be shared with other apps with instances of these containerized apps using less memory compared to virtual machines – it makes the development and deployment process more cost-effective. The software that hosts the containers is called Docker Engine. It was first started in 2013 and is developed by Docker, Inc.

Docker Workflow

How Docker works, in brief:

  1. Dockerfile– You create the blueprint for the kind of environment (container) you want.
  2. Image– You build an image from the Dockerfile.
  3. Container– You create a container from the image. All your work will be done here. You can start and stop this ‘virtual machine’ as per your need.
  4. Upload to (and download from) Cloud– Push it to DockerHub so you can download and use it anywhere.

Can Docker run Windows?

You can run both Linux and Windows programs and executables in Docker containers. The Docker platform runs natively on Linux (on x86-64, ARM and many other CPU architectures) and on Windows (x86-64). Docker Inc. builds products that let you build and run containers on Linux, Windows and macOS.

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another. A Docker container image is a lightweight, standalone, executable package of software that includes everything needed to run an application: code, runtime, system tools, system libraries and settings. Container images become containers at runtime and in the case of Docker containers – images become containers when they run on Docker Engine. Available for both Linux and Windows-based applications, containerized software will always run the same, regardless of the infrastructure. Containers isolate software from its environment and ensure that it works uniformly despite differences for instance between development and staging.

Docker containers that run on Docker Engine:

Standard: Docker created the industry standard for containers, so they could be portable anywhere
Lightweight: Containers share the machine’s OS system kernel and therefore do not require an OS per application, driving higher server efficiencies and reducing server and licensing costs
Secure: Applications are safer in containers and Docker provides the strongest default isolation capabilities in the industry

Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.

This page contains step-by-step instructions on how to get started with Docker. In this tutorial, you’ll learn how to:

  • Build and run an image as a container
  • Share images using Docker Hub
  • Deploy Docker applications using multiple containers with a database
  • Run applications using Docker Compose

In addition, you’ll also learn about the best practices for building images, including instructions on how to scan your images for security vulnerabilities.


Estimated reading time: 10 minutes

According to the 2020 Jet brains developer survey, 44% of developers are now using some form of continuous integration and deployment with Docker containers. We understand that a large number of developers have got this set up using Docker Hub as their container registry for part of their workflow. This guide contains some best practices for doing this and provides guidance on how to get started.

We have also heard feedback that given the changes Docker introduced relating to network egress and the number of pulls for free users, that there are questions around the best way to use Docker Hub as part of CI/CD workflows without hitting these limits. This guide covers best practices that improve your experience and uses a sensible consumption of Docker Hub which mitigates the risk of hitting these limits, and contains tips on how to increase the limits depending on your use case.

Inner and outer loops

To get started, one of the most important things when working with Docker and any CI/CD is to understand when you need to test with the CI, and when you can do this locally. At Docker, we think about how developers work in terms of their inner loop (code, build, run, test) and their outer loop (push changes, CI build, CI test, deployment). Before you think about optimizing your CI/CD, it is important to think about your inner loop and how it relates to the outer loop (the CI). We know that most users don’t prefer ‘debugging through the CI’. Therefore, it is better if your inner loop and outer loop are as similar as possible. We recommend that you run unit tests as part of your docker build command by adding a target for them in your Dockerfile. This way, as you are making changes and rebuilding locally, you can run the same unit tests you would run in the CI on your local machine using a simple command.

The blog post Go development with Docker is a great example of how you can use tests in your Docker project and re-use them in the CI. This also creates a shorter feedback loop on issues and reduces the amount of pulls and builds your CI needs to do.

Optimizing CI/CD deployments

Once you get into your actual outer loop and Docker Hub, there are a few things you can do to get the most of your CI and deliver the fastest Docker experience. First and foremost, stay secure. When you are setting up your CI, ensure you are using a Docker Hub access token, rather than your password.

The Docker CLI

1. Manage Docker Images

Build a Docker Image: 

Command: docker build

docker build [options] .

-t “app/container_name” # name

Description: Create an image from a Dockerfile.


2. Run a Docker Container:

Run a command in an image.

Command: docker run

docker run [options] IMAGE # see `docker create` for options

Description: Run a command in an image.


3. Manage containers

docker create

docker create [options] IMAGE
  -a, --attach               # attach stdout/err
  -i, --interactive          # attach stdin (interactive)
  -t, --tty                  # pseudo-tty
      --name NAME            # name your image
  -p, --publish 5000:5000    # port map
      --expose 5432          # expose a port to linked containers
  -P, --publish-all          # publish all ports
      --link container:alias # linking
  -v, --volume `pwd`:/app    # mount (absolute paths needed)
  -e, --env NAME=hello       # env vars


$ docker create --name app_redis_1 \
  --expose 6379 \

Create a container from an image.

4. Executing command in a container

docker exec

docker exec [options] CONTAINER COMMAND
  -d, --detach        # run in background
  -i, --interactive   # stdin
  -t, --tty           # interactive


$ docker exec app_web_1 tail logs/development.log
$ docker exec -t -i app_web_1 rails c

Run commands in a container.

5.  Start a Container

docker start

docker start [options] CONTAINER
  -a, --attach        # attach stdout/err
  -i, --interactive   # attach stdin

docker stop [options] CONTAINER

Start/stop a container.

6. Managing Container

docker ps

$ docker ps
$ docker ps -a
$ docker kill $ID

Manage containers using ps/kill.

7. Managing Images

docker images

$ docker images
  ubuntu       12.10      b750fe78269d
  me/myapp     latest     7b2431a8d968
$ docker images -a   # also show intermediate

Manages images.

8. Delete Image

docker rmi

docker rmi b750fe78269d

Deletes images.


Basic example

# docker-compose.yml
version: '2'

    build: .
    # build from Dockerfile
    context: ./Path
    dockerfile: Dockerfile
     - "5000:5000"
     - .:/code
    image: redis


docker-compose start
docker-compose stop
docker-compose pause
docker-compose unpause
docker-compose ps
docker-compose up
docker-compose down


{: .-three-column}


  # build from Dockerfile
  build: .
  # build from custom Dockerfile
    context: ./dir
  # build from image
  image: ubuntu
  image: ubuntu:14.04
  image: tutum/influxdb
  image: example-registry:4000/postgresql
  image: a4bc65fd


    - "3000"
    - "8000:80"  # guest:host
  # expose ports to linked services (not to host)
  expose: ["3000"]


  # command to execute
  command: bundle exec thin -p 3000
  command: [bundle, exec, thin, -p, 3000]
  # override the entrypoint
  entrypoint: /app/
  entrypoint: [php, -d, vendor/bin/phpunit]

Environment variables

  # environment vars
    RACK_ENV: development
    - RACK_ENV=development
  # environment vars from file
  env_file: .env
  env_file: [.env, .development.env]


  # makes the `db` service available as the hostname `database`
  # (implies depends_on)
    - db:database
    - redis
  # make sure `db` is alive before starting
    - db

Other options

  # make this service extend another
    file: common.yml  # optional
    service: webapp
    - /var/lib/mysql
    - ./_data:/var/lib/mysql

Advanced features


      com.example.description: "Accounting web app"

DNS servers



    - "/dev/ttyUSB0:/dev/ttyUSB0"

External links

      - redis_1
      - project_db_1:mysql


      - "somehost:"


To view list of all the services runnning in swarm

docker service ls 

To see all running services

docker stack services stack_name

to see all services logs

docker service logs stack_name service_name 

To scale services quickly across qualified node

docker service scale stack_name_service_name=replicas

Cleaning up

To clean or prune unused (dangling) images

docker image prune 

To remove all images which are not in use containers , add – a

docker image prune -a 

To Prune your entire system

docker system prune 

To leave swarm

docker swarm leave  

To remove swarm ( deletes all volume data and database info)

docker stack rm stack_name  

To kill all running containers

docker kill $(docekr ps -q ) 
Follow by Email

New Report