Containers are everywhere in today’s tech world. The most popular technology for container management is Docker. It makes using containers easy and helps you easily get applications up and running.

Unfortunately, this can take a lot of disk space, and you will eventually end up with a full disk.

It doesn't matter if you use Docker on your device or server. This guide shows you how you analyze used disk space and clean up different Docker resources.

All you need is a running Docker daemon and a terminal.

How to analyze how much space Docker is using

You can look up how much space is used by running the following command:

$ docker system df

TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
Images          61        16        21.1GB    15.25GB (72%)
Containers      69        0         12.26MB   12.26MB (100%)
Local Volumes   3         2         539.1MB   50.04MB (9%)
Build Cache     76        0         1.242GB   1.242GB

You can get more information by using the verbose option -v:

$ docker system df -v

REPOSITORY        TAG   IMAGE ID     CREATED       SIZE      SHARED 
teamatldocker/jira    e50b8390945c   4 weeks ago     842.3MB   0B       
vw                    ed9e125a8925   2 months ago    1.659GB   134.8MB 

Containers space usage:

CONTAINER ID   IMAGE                    COMMAND                   SIZE 
94e03a4a17d0   teamatldocker/jira       "/sbin/tini -- /usr/…"    1.4MB 

Local Volumes space usage:

VOLUME NAME                     LINKS     SIZE
play-with-jira_postgresqldata   1         84.19MB   
play-with-jira_jiradata         1         404.8MB

Build cache usage: 1.242GB

CACHE ID       CACHE TYPE     SIZE      CREATED        LAST USED 
oxil5sdicb91   regular        135MB     2 months ago   2 months ago  
kxz13fmdbodg   regular        13B       2 months ago   2 months ago 
nysus21ej7pf   regular        0B        2 months ago   2 months ago

As you can see, you get information about:

• Images space usage,
• Containers space usage,
• Local Volumes space usage, and
• Build cache usage.

How to Clean Up Everything in Docker

You can clean up everything or clean up specific resources in Docker like images, container volumes, or the build cache.

To clean up as much as possible excluding components that are in use, run this command:

$ docker system prune -a

-a includes unused and dangling containers. Not providing -a would only delete dangling images, which are untagged images that have no relationship to any other images.

If you want to clean up most Docker resources but still keep tagged images, you can execute this command:

$ docker system prune

This is all you need to free up disk space quickly. Additionally, you can clean up components separately.

Here are a few more useful commands:

Clean up unused and dangling images

$ docker image prune

Clean up dangling images only

$ docker image prune -a

Clean up stopped containers

$ docker container prune

Clean up unused volumes

$ docker volume prune

How to Continuously Manage Your Used Docker Space Efficiently

You can run something on a daily basis or at startup. To skip the usual prompt, you need to add -f to the command you want to run automatically.

Keep in mind that this will cause you to download images much more often because you regularly remove Docker resources.

If you don’t have a disk space issue, then don’t worry. Just clean things up as soon as heavy Docker disk usage catches your attention.

Conclusion

Today, there are many ways of cleaning up Docker disk space using the docker command. You can even execute these commands automatically if you want to clean up Docker resources regularly.

I hope you enjoyed the article.

If you liked it and felt the need to give me a round of applause or just want to get in touch, follow me on Twitter.

I work at eBay Kleinanzeigen, one of the world’s biggest classified companies. By the way, we are hiring!

We live in an era where storage is becoming cheaper everyday. We can just send everything to the cloud and pay almost nothing.

So why would we need to worry about deleting Docker images?

First of all, there are still some mission critical workloads that can't be moved to the cloud, especially those in heavily regulated industries like law or healthcare.

But to better answer that question, I would say that we as developers often find ourselves out of space on our local machines.

Let's do a quick analysis of this StackOverflow public dataset to explore that further:

SELECT tag,
       title,
       answer_count,
       favorite_count,
       score,
       view_count VIEWS
FROM
  (SELECT title,
          answer_count,
          favorite_count,
          view_count,
          score,
          SPLIT(tags, '|') tags
   FROM `bigquery-public-data.stackoverflow.posts_questions` 
         posts_questions), UNNEST(tags) tag
WHERE tag = 'docker'
  AND title LIKE '%space left%'
ORDER BY VIEWS DESC

Query Results:

So it does't happen just with me, right? Look at how many views we have on those StackOverflow posts. If you are wondering, the number is 465687 views for posts matching the search query.

Luckily for us, today we are going to see some easy-to-use examples on how to delete our dangling and unused docker images to help ourselves out.

What are dangling and unused Docker images?

What is the difference between dangling and unused images, you might ask?

A dangling image means that you've created a new build of the image but haven't given it a new name. Think about those old, forgotten images that no one knows what to do with anymore – those are "dangling images".

They are left untagged and display <none> on their name when you run docker images.

On the other hand, an unused image means that it has not been assigned or is not being used in a container.

For example, when running docker ps -a – it will list all your currently running containers plus exited containers. Any images being used inside any of containers are shown as "used images", and any others are unused.

Delete Docker Images

Now let's see some examples of how to delete Docker images.

Our case study

The Busy Cat Corp is a fictional company that captures cat behavior data, and provides recommendations to cat owners on how to make their pets busier and happier.

All their workloads are containerized, and they use the following database images:
cassandra, postgres, mysql and mongo.

Their developers are constantly running out of space on their machines, and they are top users of StackOverflow – aren't we all?

So they asked us for some quick examples of how to delete some images and get their space back.

First let's take a look at the machine of one of their developers.

docker images

Output

REPOSITORY  TAG          IMAGE ID            CREATED              SIZE
<none>       <none>      9c872a6119cc        About a minute ago   384MB
mysql        latest      5ac22cccc3ae        43 hours ago         544MB
cassandra    3           9fab0c92a93d        4 days ago           384MB
adoptopenjdk 8-jre...    2bf0172ac69b        4 days ago           210MB
mongo        latest      6d11486a97a7        2 weeks ago          388MB
postgres     latest      b97bae343e06        6 weeks ago          313MB

That's cool, they have all the images from their workloads downloaded. But look at the disk space – it's more than 2GB! Let's see what we can do for them.

Delete Docker dangling images

We'll start by looking for dangling images.

docker images -qf "dangling=true"

Output

REPOSITORY  TAG          IMAGE ID            CREATED              SIZE
<none>       <none>      9c872a6119cc        About a minute ago   384MB

We have one, so we are going to clear it up.

Delete the dangling image

docker rmi $(docker images -qf "dangling=true")

Delete Docker unused images

Next we are looking for unused images.

docker ps -a

Output

CONTAINER ID  IMAGE   CREATED           NAMES
b6387b343b81  mysql   16 minutes ago    some-mysql

We only have one container running the mysql image, so all the other images are unused.

So that we don't have to do it manually, we can put together a script that shows all of the unused images to verify them.

# Get all the images currently in use
USED_IMAGES=($( \
    docker ps -a --format '{{.Image}}' | \
    sort -u | \
    uniq | \
    awk -F ':' '$2{print $1":"$2}!$2{print $1":latest"}' \
))

# Get all the images currently available
ALL_IMAGES=($( \
    docker images --format '{{.Repository}}:{{.Tag}}' | \
    sort -u \
))

# Print the unused images
for i in "${ALL_IMAGES[@]}"; do
    UNUSED=true
    for j in "${USED_IMAGES[@]}"; do
        if [[ "$i" == "$j" ]]; then
            UNUSED=false
        fi
    done
    if [[ "$UNUSED" == true ]]; then
        echo "$i is not being used."
    fi
done

Output

adoptopenjdk:8-jre-hotspot-bionic is not being used.
cassandra:3 is not being used.
mongo:latest is not being used.
postgres:latest is not being used.

Then it deletes the unused images.

# Get all the images currently in use
USED_IMAGES=($( \
    docker ps -a --format '{{.Image}}' | \
    sort -u | \
    uniq | \
    awk -F ':' '$2{print $1":"$2}!$2{print $1":latest"}' \
))

# Get all the images currently available
ALL_IMAGES=($( \
    docker images --format '{{.Repository}}:{{.Tag}}' | \
    sort -u \
))

# Remove the unused images
for i in "${ALL_IMAGES[@]}"; do
    UNUSED=true
    for j in "${USED_IMAGES[@]}"; do
        if [[ "$i" == "$j" ]]; then
            UNUSED=false
        fi
    done
    if [[ "$UNUSED" == true ]]; then
        docker rmi "$i"
    fi
done

After deleting both dangling and unused images we can look at what we have left.

docker images

Output

REPOSITORY  TAG          IMAGE ID            CREATED              SIZE
mysql        latest      5ac22cccc3ae        43 hours ago         544MB

So we only have the mysql image remaining, that's great!

Delete all obsolete Docker images with prune

Those commands sound great, but a second developer said they didn't care about the differences between dangling and unused images.

All they wanted was to clear obsolete images and get their disk space back.

Personally this is what I usually do.

So we can just use Docker's prune commands.

# First delete all stopped containers
docker container prune

# Then delete both dangling and unused images
docker image prune --all

This will delete both unused and dangling images. Or in other words images without at least one container associated with them.

Note: this is why we needed to first delete the stopped containers in the code above.

Wrapping up**

In this article we saw how to delete Docker Images, and we used a fictional company to explain it with some easy-to-use examples.

It's important to point out that you shouldn't use Docker to keep a history of your old images. For a developer environment that's fine, and you can even automate the image clean up workload if you have to deal with a lot of them.

But for a production workload, you should be using a Container Registry solution to handle your Docker images.

There are many Container Registry solutions out there, like Google Cloud Platform with Artifact Registry and Docker Enterprise with Docker Trusted Registry. And if you are in the open source world, you can just use Docker Hub :).

Thanks for reading!

• Illustrations from Icons8

If you found this helpful, or wish to challenge or extend anything raised here, feel free to contact me on Twitter or Linkedin. Let's connect!

I'm going to let you in on a DevOps secret here: The thing all DevOpsy people love to do is build a super fancy and complex system, then find a way to deal with it like a regular shell. Or connect to it with SSH and then treat it like a regular shell.

Docker is no different! You are running a computer inside some other computer. Maybe that computer is an EC2 instance or a laptop. You can even get really crazy and run a VM that is then running Docker.

Most of the time when I use Docker I am using it to package and distribute an application. Sometimes I'm using it for something cooler like a distributed computing project. But a lot of times I'm throwing a Dockerfile in a GitHub repo so that I don't have to install CLIs that I just know will eventually conflict on my laptop.

Long story short, you can tell Docker to run the command bash, which drops you into a shell:

docker run -it name-of-image bash
# docker run -it continuumio/miniconda3:latest bash
# docker run -it node:latest bash

But keep reading for more. ;-)

Try it out

Google your favorite programming language's Docker up. For me this is Python, and specifically I like conda. Then run a few commands to make sure that you are in fact in that shell.

# From Host
echo $(pwd)
# Drop into docker shell
docker run -it continuumio/miniconda3:latest bash
# Now you are in the docker shell!
echo $(pwd)
echo $USER

Cool, huh? This is perfect for debugging a container that absolutely should be working properly. It's also great for my most common "I don't want to install this to my computer" use case.

Debug a Docker Build with Docker Run

Treating your Docker image like a regular shell will come in handy when trying to debug Docker builds.

Let's say you have a Dockerfile for an image you are trying to build. Normally what happens is that when running docker build -t my-image . (-t is for tag) Docker will run through each of your RUN steps, and stop when it gets to a command that does not exit properly.

In a UNIX shell, the exit code 0 means that all is well with a command. So to illustrate this point I have made our Dockerfile have a RUN command that exits with 1.

FROM continuumio/miniconda3:latest

RUN apt-get update -y; \
    apt-get upgrade -y; \
    apt-get install -y \
    vim-tiny vim-athena build-essential

RUN  conda update conda \
    && conda clean --all --yes

RUN exit 1

docker build -t my-image .

This will get you an output that looks like:

(base) ➜  my-image docker build -t my-image .
Sending build context to Docker daemon  2.048kB
Step 1/4 : FROM continuumio/miniconda3:latest
 ---> 406f2b43ea59
Step 2/4 : RUN apt-get update -y;     apt-get upgrade -y;     apt-get install -y     vim-tiny vim-athena build-essential
 ---> Using cache
 ---> 726af29a48a0
Step 3/4 : RUN  conda update conda     && conda clean --all --yes
 ---> Using cache
 ---> 19478bb3ce67
Step 4/4 : RUN exit 1
 ---> Running in 7c98aab6b52c
The command '/bin/sh -c exit 1' returned a non-zero code: 1

You can confirm that your Docker image wasn't built by running docker images and checking for my-image. It won't be there because it wasn't successfully built.

Now what we can do is to comment out that troublesome Dockerfile RUN command.

FROM continuumio/miniconda3:latest

RUN apt-get update -y; \
    apt-get upgrade -y; \
    apt-get install -y \
    vim-tiny vim-athena build-essential

RUN  conda update conda \
    && conda clean --all --yes

#RUN exit 1

Then what you will see is:

Sending build context to Docker daemon  2.048kB
Step 1/3 : FROM continuumio/miniconda3:latest
 ---> 406f2b43ea59
Step 2/3 : RUN apt-get update -y;     apt-get upgrade -y;     apt-get install -y     vim-tiny vim-athena build-essential
 ---> Using cache
 ---> 726af29a48a0
Step 3/3 : RUN  conda update conda     && conda clean --all --yes
 ---> Using cache
 ---> 19478bb3ce67
Successfully built 19478bb3ce67
Successfully tagged my-image:latest

You can now drop into your Docker image and start interactively running commands!

docker run -it my-image bash
# you can also run
# docker run -it my-image:latest bash

From here, one by one, you can start debugging your RUN commands to see what went wrong. If you're not sure if a command exited properly or not, run $?:

# First run docker run -it my-image bash to get to the shell
# Print the string hello
echo "hello"
# hello
echo $?
# 0

# Run a non existant command hello
$(hello)
# bash: hello: command not found
echo $?
# 127

You can keep running these steps, commenting out your Dockerfile, dropping into a shell, and figuring out problematic commands, until your Docker images builds perfectly.

Wrap Up

Hopefully I have shown you that using a Docker image is no different from the terminal on your computer. Using Docker images is an awesome way to distribute applications.

Try to take your favorite CLI application or next GitHub project, and instead of creating an install script, package it up with Docker. ;-)

This guide shows you how to use Docker to pull a MSSQL Server image and run it. Azure Data Studio is a cross-platform database tool that will be using to connect our Docker container with MSSQL and execute SQL statements.

At the end, I will show you how to import a database to the Docker file system so that you can access it through Azure Data Studio.

Check out other related guides here:

• How to Connect your AWS RDS Microsoft SQL Server using Azure Data Studio
• How to Import a Sample Database to your AWS RDS Microsoft SQL Server using S3

We will be touching on the technologies shown below:

• Database: Microsoft SQL Server
• Container to pull mssql-server-demo: Docker
• Installer for mssql-cli: Node.js (Run-time Environment) / Node Package Manager (NPM)
• Database tool and GUI: Azure Data Studio

Building our Environment with Docker

Installing Docker

Full guide for this portion here:

1. Download Docker CE (Community Edition) for Mac here.
2. To install, double-click on the .dmg file and then drag the Docker application icon to your Application folder.

What is Docker?

Docker is a platform that enables software to run in its own isolated environment. SQL Server (from 2017) can be run on Docker in its own isolated container.

Once Docker is installed, you simply download — or “pull” — the SQL Server on Linux Docker Image to your Mac, then run it as a Docker container. This container is an isolated environment that contains everything SQL Server needs to run.

Launch Docker

Open your Docker application, it should be located in the Applications folder.

Increase the Memory

By default, Docker will have 2GB of memory allocated to it. SQL Server needs at least 3.25GB. To be safe, increase it to 4GB if you can. Since this is just a playground, 2GB should be enough.

Optional - in case you want to increase memory size:

1. Select Preferences from the little Docker icon in the top menu
2. Slide the memory slider up to at least 2GB
3. Click Apply & Restart

Download SQL Server

Open a Terminal window and run the following command.

sudo docker pull mcr.microsoft.com/mssql/server:2019-latest

This downloads the latest SQL Server 2019 for Linux Docker image to your computer.

You can also check for the latest container version on the Docker website if you wish.

Launch Docker Image

Run the following command to launch an instance of the Docker image you just downloaded:

docker run -d --name sql_server_demo -e 'ACCEPT_EULA=Y' -e 'SA_PASSWORD=really

Example output:

Check the Docker container (optional)

You can type the following command to check that the Docker container is running.

docker ps

If it’s up and running, it should return something like this:

If you accidentally closed your Docker App, open your terminal and type

docker start sql_server_demo

Install the Node.js and NPM

Check if you have Node.js and NPM. Run the following commands in your terminal.

node -v
npm -v

If you get an output with a version number, skip the rest of this section.

Then visit the Node.js website by clicking the following link:

https://nodejs.org/en/

Click the LTS version (the version number may be various) download button to download the Node.js package:

Next click and run the package after downloading. MacOS and Windows will have different installation process. Please follow the instruction to install the Node.js.

Then test again if Node.js and NPM were installed successfully by running the following commands in the terminal:

node -v
npm -v

An output should look like this:

####

Install sql-cli

Run the following command to install the sql-cli command line tool. This tool allows you to run queries and other commands against your SQL Server instance.

npm install -g sql-cli

If you get a permission error, use the sudo command:

sudo npm install -g sql-cli

###

Connect to MSSQL Server

Connect to your SQL Server using the mssql command, followed by the username and password parameters. Syntax: -u -p

mssql -u sa -p reallyStrongPwd123

Your output should look like this if you successfully connected:

Run a Quick Test

Run a quick test to check if you can connect to your SQL Server. Use the following SQL statement to check your SQL Server version:

SELECT @@VERSION;

If it’s running, you should see something like this:

Download an SQL Server GUI - Azure Data Studio

Azure Data Studio (formerly SQL Operations Studio) is a free GUI management tool that you can use to manage SQL Server on your computer. You can use it to create and manage databases, write queries, backup and restore databases, and more.

Azure Data Studio is available on Windows, Mac and Linux.

Install Azure Data Studio

To install Azure Data Studio onto your Mac:

1. Visit the Azure Data Studio download page, and click the .zip file for macOS
2. Once the .zip file has finished downloading, double click it to expand its contents
3. Drag the .app file to the Applications folder (the file will probably be called Azure Data Studio.app)

Connect to SQL Server

Now that Azure Data Studio is installed, you can use it to connect to SQL Server.

1. Launch Azure Data Studio. It is located in your Applications folder.
2. Enter the login credentials and other information for the SQL Server instance that you’d like to connect to:

It should look similar to this:

It should look similar to this:

• Server Name: localhost, [port number]
  Example: localhost, 1433
• Authentication Type: SQL Login
• User name: [your SQL Server username] or sa
• Password: [your SQL Server password] or reallyStrongPwd123
• Database Name:
• Server Group:

If you use a port other than the default 1433, click Advanced and enter it in the Port field.

Alternatively, you can append it to your server name with a comma in between. For example, if you used port 1400, type in localhost,1400.

You can now go ahead and create databases, run scripts, and perform other SQL Server management tasks.

1. Click New Query

2. Type SELECT @@VERSION, then Click Run Query.

You should be able to see: Microsoft SQL Server in the Results.

Importing a sample database to your SQL Server using Azure Data Studio

Download the sample database file AdventureWorks

To get the OLTP downloads of AdventureWorks, go to this link and choose any sample database. In my example, I choose AdventureWorks2017.bak. We will upload this to the S3 Bucket.

Copying the file to your docker

Type the following command in the terminal following this syntax:

docker cp <location_of_file> <container_id>:/var/opt/mssql/data

It should look like this:

If you forgot your container id, use the docker ps command.

Importing the sample database in Docker

Go to Azure Data Studio, and click the localhost, 1443, then choose Restore.

Then choose Backup file as the selection for Restore from. Next, click the blue button on the right of Backup file path.

Look for the sample database file. It should be located in

/var/opt/mssql/data/AdventureWorks2017.bak

Choose Restore.

Check your localhost, 1443. It should generated a Database named AdventureWorks2017 and have contents such as Tables and Views. If not, right-click on localhost, 1443 and choose Refresh. You can also restart your Azure Data Studio application.

Testing the sample database

1. Choose AdventureWorks2017 from the dropdown menu.
2. Write a SQL query:

SELECT * FROM HumanResources.Department;

3. Click Run to run the query.

You should have an output like this:

Congratulations! ???

Resources:

• How to Install SQL Server on a Mac

Connect with me on LinkedIn here

With the passage of time running Docker in development, we tend to accumulate a lot of unused images. Sometimes for testing, research or just trying out fun new stuff. It's always cool to run new software in containers, lights up new possibilities for those of us interested in constantly learning new technologies. Downside is a lot of precious SSD memory occupied with rarely used or unused images, the worse thing is we hardly notice. But the guys at Docker Inc. have done a great task by keeping a track of all things Docker.

Say hello to the system command, part of the docker management commands and simply awesomeness. The system command provides info from disk usage to system-wide information, ain’t that cool.

Disk usage using **df** command:

$ docker system df

Returns something like this,

TYPE              TOTAL     ACTIVE     SIZE         RECLAIMABLE
Images            35        6          8.332GB      7.364GB (88%)
Containers        12        12         417.6MB      0B (0%)
Local Volumes     67        2          2.828GB      2.828GB (100%)
Build Cache                            0B           0B

Notice the Reclaimable this is the size you can recover, it is calculated by subtracting the size of active images from the size of total images.

Real time events using **events** command:

$ docker system events

Returns the list of real time events from the server, based on Docker object types.

Formatting output

--format 'Type={{.Type}}  Status={{.Status}}  ID={{.ID}}'

or simply format the output as JSON

$ docker system events --format '{{json .}}'

System-wide info using **info** command:

Another cool command to get all the system related information is the info command. You will be amazed to see the amount of info you can get.

$ docker system info

Remove unused data using **prune** command:

Now that we have all the info we need, its cleanup time, but beware against using this command half asleep.

$ docker system prune
WARNING! This will remove:        
    - all stopped containers        
        - all networks not used by at least one container        
        - all dangling images        
        - all build cache
Are you sure you want to continue? [y/N]

Further we can remove exactly what we want, using any of the following commands, feast you eyes ladies and gents.

$ docker system prune -a --volumes
$ docker image prune
$ docker container prune
$ docker volume prune
$ docker network prune

All of the above commands will prompt for confirmation, so wash your face with cold water or take a shot of Espresso before issuing any of these ;).

Install Docker, create your first container, and more

You may have seen Docker somewhere on the internet and you may feel curious about it. Now you want to take it to the next level. How about going on a date with Docker? No — I am not kidding!

But, how do you plan a perfect first date? What should you do? Where to find the right resources? What prerequisites might you need?

The questions are endless. Follow these first-date guidelines, and you’ll be well on your way to landing a second.

Planning your date

Getting to know your date before you start planning is crucial to crafting a memorable first experience. It will likely boost your confidence during the meeting, as well.

It’s never too late to say Hi. Here is a short introduction to my first time meeting Docker if you’re interested.

Okay! So the road map we will follow today looks something like this:

1. Setting up the Venue
2. The Pickup
3. The Conversation

Prelude

The place where we will set up our date is the Docker engine.

Docker engine is no different from any other engine. It is a combination of various components working together.

We will see a few of these components later in this article. But for now, let’s decorate our machine with Docker. The installation process depends upon your operating system.

The key for uninterrupted execution is always to refer to an official website. Docker has this fantastic guide, where you can find out more about installation.

Docker comes in two flavors: Docker Community Edition (CE) and Docker Enterprise Edition (E.E.). For our demonstration purposes, we must stick to the community edition. The Enterprise Edition is paid. And besides, making an expensive reservation for your first date is not the best idea ?

The Venue

The core mantra for any propitious date is to choose the right meeting place. Meeting Docker is no different. First, we should decide on the platform. Cloud? Mac? Linux? Or Windows? Once we know our environment, we can choose the simplest way to set up the meeting place.

Windows

If your choice is Windows, the process for setup is quite simple. Remember our favorite process: Next, Next, Next, and Finish.

Jump to the download page and choose the “Edge channel.” Edge has experimental features and fits best for our learning purposes.

Note! Docker for Windows needs the “Hyper-V” feature, but there is nothing to worry about — Docker will turn it on for you. However, it means that you can’t use Virtual Box.

Linux

When I first started experimenting on a Linux box, I thought it was going to be a nightmare. But to my relief, setting up Docker on a Linux distribution turned out to be simple. Again, there are many ways to install Docker on a Linux distribution.

My favorite is: “Install using the convenience script.” We grab a long shell script from the internet and then pipe it to a shell terminal.

How? Like this:

sudo wget -qO- https://get.docker.com |sh

Done! Yeah, you have Docker on your machine up and running.

Now that the venue is all set, we are ready to proceed. But first, let’s make some inquiries to make sure everything is working fine here. The same as you might inquire with a restaurant before booking a table ?.

Let’s execute the below command in the terminal:

docker version

You should see the installation details. It gives you information about the Client and Server version, the Go-lang version, and so on and so forth.

If the output of your command is somehow like the one below, the sun is shining, and the world is beautiful. Next: time to get ready for the “Pickup.”

Command output

The Pickup

As you may already be aware, Docker uses Images to create containers. These images are large binary immutable files.

An image contains application binaries and their dependencies. It may also contain other components such as a web server or even an OS.

We will need such images to create a container and run an application inside it.

So, where do these images live? Simple question, simple answer: on a Host. This host can be your machine or a registry somewhere on the internet. Docker has its registry called Docker-Hub.

To avoid wandering, you should know the right pickup location for your date.

To make your first date smoother, I found the exact location of an image that I can share with you. Excited enough? Here you go!

docker pull chandrabhan/dotnetconsole

Let’s confirm that we are at the right location. ?

docker image ls

command output

Here you can see various properties of the images on your machine. Cool, it looks like things are going good so far.

Before moving further, let’s break down the previous two commands and understand what’s going on here.

With Docker pull, we asked Docker Daemon to pull an image for us. The Daemon could not find the image in the local registry, so it went ahead and pulled a remote copy from Docker-Hub.

Through docker image ls we saw all available images and their properties.

I must admit, I am getting excited. We’ve done a great job so far. Next, let the interaction begin.

The Conversation

Start the conversation, and things will turn out in your favor.

So again, to make it smoother for you, I want to offer you a few icebreakers.

We will create some containers for .Net Core framework applications. The first one will be a simple console application. The other will be a bit more colorful — a web application.

docker run chandrabhan/dotnetconsole

command output

Magnificent! Did you see what happened there? This stuff is amazing. A .Net core application is running inside a container. Docker went ahead and created a container and executed the application inside it. And as soon as the console application ends, the container exists!

Let’s see how many containers we have in our machine:

docker container ls -a

command output

What you see here is the list of containers on your machine. You can identify a container by its **ID**. The output tells us when the container was **CREATED** and what it’s current **STATUS** is. The container we created is in **Exited** status. Remember? Our application is exited! So is the container.

It looks like the conversation is progressing well, so let’s keep going.

docker run -it --rm -p 5000:80 --name app chandrabhan/aspdotnet

Go to your favorite browser and browse http://localhost:5000. You should see more amazing stuff.

An ASP.Net core web app is running inside a container:

containerized - sample ASP.Net application

Before moving further, let’s see the anatomy of the above command.

command anatomy

Did you notice? This time we did not pull the image, but we were still able to create a container out of it. When you execute docker run, Docker daemon tries to find a local copy of the image. If it cannot, it goes ahead and tries to find it in the default registry (Docker-Hub in this case).

I believe our planning was excellent and so was the execution. Let’s rewind what we did and review how we planned an auspicious date with Docker ?.

Rewinding

1. First, we installed Docker. We saw how the installation process varies depending on the operating system.
2. Then we went ahead and pulled an image from the Docker-Hub registry, a simple .Net Core console app.
3. Once we had this image on our machine, we used Docker to create a container out of this image.
4. We also saw how to pull an image and run a container through a single command.

Here is an illustration that may help you understand a high-level picture.

illustration: Docker client and daemon

Follow up

Out of sight out of mind

Following up is as important as any other stage during the date. Now I should leave you with your date, and would like to hear how it went. Below are a few links that may be useful:

• Github
• Docker hub