Using Docker – Installation

If you follow me on Twitter (@john_canessa) you have noticed that in the past couple months or so I have been posting tweets regarding articles in Medium. The site is geared to creating posts which you could do using your own web site (e.g., www.johncanessa.com). The beauty is that many talented individuals in different fields are posting there. The site organizes them by categories and presents the articles indicating the estimated reading time. One of these days I will probably start posting there.

Of dozens of articles that I have read on Medium, I have noticed that explicitly or implicitly the way they are written follows two well known patterns which I have used for decades. The first one is to read and then experiment. One can read about a subject and get a general idea on it. You need to experiment, make mistakes and use or create examples that interest you. The second pattern is to explain the subject at a 6 year old level. Not all the articles get to this point, but in general the authors attempt to explain as simply as possible the steps to achieve a goal. At work I architect, design and implement code attempting to explain as well as I can. Keep in mind that if you cannot explain something, you do not understand it yourself.

I am very interested, among other things, in Docker. This post deals with chapter two of the book “Using Docker” by Adrian Mouat, ISBN: 978-1-491-91576-9. I have read a few books regarding Docker and have found this as the best so far. I typically get my books from Amazon. I strongly recommend getting a copy, reading a chapter at a time and then spending time experimenting as long as you think is enough with the examples. In future posts, I will be touching on most (if not all the chapters) in the “Using Docker” book.

If you have been reading my posts and tweets, I am very interested in what is generally known as Artificial Intelligence (AI). One of the languages mostly used is Python. There is a Jupyter Notebook that in one place (the notebook) an author / developer can put the code, the engine that parses the code and the actual data. That is a great thing to use. If you have an issue, you can send / post the notebook and a reviewer is able to follow the code and reproduce the bugs / results. This is great for peer review.

Of course there are some limitations. I am not sure how many other languages are supported by Jupyter. One must also take into considerations the different versions of hardware, operating systems, and tools. Docker deals with containers. In a nutshell a container represents a virtual computer that has been used to test / run the software being developed. The great thing of Docker is that the virtual computer with the actual code and data can be shared and runs on most (never say any) machines with some limitations. For example, a Docker container created under Windows runs on Windows machines. The same holds true for Linux. Given that Docker was developed using Linux features, we will use Linux in this set of posts.

If you are interested and getting a better overview regarding containers and in specific Docker, the first chapter in “Using Dockers” might be all what you need. There is a lot of information on the web; some of which may be overkill and / or not be up to date.

Without further ado, let’s dive into the subject of this post.

The first thing to do is to install Docker on your machine. I have installed it on Linux and Windows. It makes sense to start with Linux, and if needed move on to Windows.

You need to have a relatively current version of Linux and download and install a current version of Docker. Both Docker and Linux are constantly and rapidly evolving so it is not a good idea to use stale versions.

Let’s determine the version of Linux running on our machine. The following command lists a set of one of more files which contain the information we are seeking. At this time we do not know the exact count or names.

$ ls -l /etc/*-release      
-rw-r--r--. 1 root root  38 Aug 30 10:53 /etc/centos-release
-rw-r--r--. 1 root root 393 Aug 30 10:53 /etc/os-release
lrwxrwxrwx. 1 root root  14 Nov  5 20:09 /etc/redhat-release -> centos-release
lrwxrwxrwx. 1 root root  14 Nov  5 20:09 /etc/system-release -> centos-release

By the names of the files it seems that we are running a Linux CentOS distribution. We can now take a look at the contents of the different files and get the actual name of the distribution by using:

$ tail -vn +1 /etc/*-release
==> /etc/centos-release <== CentOS Linux release 7.4.1708 (Core) ==> /etc/os-release <== NAME="CentOS Linux" VERSION="7 (Core)" ID="centos" ID_LIKE="rhel fedora" VERSION_ID="7" PRETTY_NAME="CentOS Linux 7 (Core)" ANSI_COLOR="0;31" CPE_NAME="cpe:/o:centos:centos:7" HOME_URL="https://www.centos.org/" BUG_REPORT_URL="https://bugs.centos.org/" CENTOS_MANTISBT_PROJECT="CentOS-7" CENTOS_MANTISBT_PROJECT_VERSION="7" REDHAT_SUPPORT_PRODUCT="centos" REDHAT_SUPPORT_PRODUCT_VERSION="7" ==> /etc/redhat-release <== CentOS Linux release 7.4.1708 (Core) ==> /etc/system-release <==
CentOS Linux release 7.4.1708 (Core)

The /etc/centos-release file indicates we are using CentOS Linux release 7.4.1708 (Core). Any version greater or equal to CentOS 7.0 is good.

We can now check that the Linux kernel version and CPU architecture is what Docker requires. We can do this as follows:

$ uname -a
Linux localhost.localdomain 3.10.0-693.11.6.el7.x86_64 #1 SMP Thu Jan 4 01:06:37 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux

This command lists all the information but we need to know where it is located in the string. To get the Linux kernel version:

$ uname -r
3.10.0-693.11.6.el7.x86_64

We are running a version that is higher than 3.10. All is well so far.

We should verify that our CPU is 64-bit and not 32-bit. The following command will display the CPU architecture:

$ uname -m
x86_64

This is a 64-bit processor so we are good.

The next step is to download the installation script for Docker. We can download it using one of the two commands:

$ curl https://get.docker.com > /tmp/install.sh
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  100 11249  100 11249    0     0   2133      0  0:00:05  0:00:05 --:--:-- 63553

OR

$ curl -fsSL get.docker.com -o /tmp/install.sh

Once the script has been downloaded you might want to take a look at what it does. Opening the file with a text editor to review it makes sense:

$ gvim /tmp/install.sh

I like to use gvim, but any other editor (not word processor) would be fine.

To install Docker I used the following:

$ chmod +x /tmp/install.sh
$ /tmp/install.sh

After Docker was installed, I removed the installation script. You may choose to keep it for later reference.

$ rm /tmp/install.sh

If you would like to use Docker as a non-root user, you should now consider adding your user to the “docker” group with something like:

$ sudo usermod -aG docker johncanessa

The “Using Docker” book suggests running in permissive (0) mode. My installation started as follows:

$ sestatus
SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted
Current mode:                   enforcing
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Max kernel policy version:      28

You can change the current mode (enforcing == 1 OR permissive = 0)

$ sudo setenforce 0

I decided to leave it in enforcing and decide to switch to permissive if and when the need arises.

To start the Docker service you may enter the following command:

$ sudo service docker restart

At this point if all went well, Docker should be up and running. To verify this you could use the following:

$ docker version
Client:
 Version:	18.02.0-ce
 API version:	1.36
 Go version:	go1.9.3
 Git commit:	fc4de44
 Built:	Wed Feb  7 21:14:12 2018
 OS/Arch:	linux/amd64
 Experimental:	false
 Orchestrator:	swarm

Server:
 Engine:
  Version:	18.02.0-ce
  API version:	1.36 (minimum version 1.12)
  Go version:	go1.9.3
  Git commit:	fc4de44
  Built:	Wed Feb  7 21:17:42 2018
  OS/Arch:	linux/amd64
  Experimental:	false

If the Docker server portion does not display, there is an issue that needs to be resolved. In my case all went well. I recall the first time I installed Docker on Windows; the server did not come up. After enabling some software and adding some RAM, all came up.

A command you might want to keep handy is:

$ docker help

Usage:	docker COMMAND

A self-sufficient runtime for containers

Options:
      --config string      Location of client config files (default "/home/johncanessa/.docker")
  -D, --debug              Enable debug mode
  -H, --host list          Daemon socket(s) to connect to
  -l, --log-level string   Set the logging level ("debug"|"info"|"warn"|"error"|"fatal") (default "info")
      --tls                Use TLS; implied by --tlsverify
      --tlscacert string   Trust certs signed only by this CA (default "/home/johncanessa/.docker/ca.pem")
      --tlscert string     Path to TLS certificate file (default "/home/johncanessa/.docker/cert.pem")
      --tlskey string      Path to TLS key file (default "/home/johncanessa/.docker/key.pem")
      --tlsverify          Use TLS and verify the remote
  -v, --version            Print version information and quit

Management Commands:
  config      Manage Docker configs
  container   Manage containers
  image       Manage images
  network     Manage networks
  node        Manage Swarm nodes
  plugin      Manage plugins
  secret      Manage Docker secrets
  service     Manage services
  swarm       Manage Swarm
  system      Manage Docker
  volume      Manage volumes

Commands:
  attach      Attach local standard input, output, and error streams to a running container
  build       Build an image from a Dockerfile
  commit      Create a new image from a container's changes
  cp          Copy files/folders between a container and the local filesystem
  create      Create a new container
  diff        Inspect changes to files or directories on a container's filesystem
  events      Get real time events from the server
  exec        Run a command in a running container
  export      Export a container's filesystem as a tar archive
  history     Show the history of an image
  images      List images
  import      Import the contents from a tarball to create a filesystem image
  info        Display system-wide information
  inspect     Return low-level information on Docker objects
  kill        Kill one or more running containers
  load        Load an image from a tar archive or STDIN
  login       Log in to a Docker registry
  logout      Log out from a Docker registry
  logs        Fetch the logs of a container
  pause       Pause all processes within one or more containers
  port        List port mappings or a specific mapping for the container
  ps          List containers
  pull        Pull an image or a repository from a registry
  push        Push an image or a repository to a registry
  rename      Rename a container
  restart     Restart one or more containers
  rm          Remove one or more containers
  rmi         Remove one or more images
  run         Run a command in a new container
  save        Save one or more images to a tar archive (streamed to STDOUT by default)
  search      Search the Docker Hub for images
  start       Start one or more stopped containers
  stats       Display a live stream of container(s) resource usage statistics
  stop        Stop one or more running containers
  tag         Create a tag TARGET_IMAGE that refers to SOURCE_IMAGE
  top         Display the running processes of a container
  unpause     Unpause all processes within one or more containers
  update      Update configuration of one or more containers
  version     Show the Docker version information
  wait        Block until one or more containers stop, then print their exit codes

Run 'docker COMMAND --help' for more information on a command.

I tend to forget things so taking note on how to get some help is always useful.

You should first read the second chapter in “Using Docker”; follow the steps and then try different things to learn and understand how to install Docker.

In a following post I will cover the next chapter in the book.

John

www.johncanessa.com

@john_canessa

Leave a Reply

Your email address will not be published. Required fields are marked *