1. Introduction

• Containerization is about packaging an application, libraries and configuration as an image

• The image can be shared easily with others publicly or in a limited scope

• Instances of the image (the containers) can be quickly spawned in a portable way

• Containers are isolated from the host system and from each other (except when explicitly configured otherwise)

  • This allows to design a software system as a set of communicating microservices
  • This also enhances security, because a compromised component does not grant access to the rest of the system

2. Containerization vs Virtualization

• VMs emulate the whole stack (hardware + software), while containers share some of the resources with the host system
• VMs require more resources to operate and take longer to start
• VMs are usually mutable -- one creates an instance from base image, then installs X and configures Y, then after a few weeks one installs Z, etc.
• Containers are immutable -- if you want to update X installed, you rebuild the container image and restart it

3. Container types

• A system container is one which emulates VM behaviour
• It has a main process (/sbin/init) able to spawn other daemons and foreground applications
• An application container has just one application running as its only process
• The best practice is to design application containers and connect them using well-defined channels

4. Basic commands

• These examples use Docker as the container engine

• To download ubuntu image from the public repository:

  docker pull ubuntu
  

• To list available images:

  docker images
  

• To run a container from ubuntu image:

  docker run -it ubuntu
  

  • The -it stands for:

      -i, --interactive                    Keep STDIN open even if not attached
      -t, --tty                            Allocate a pseudo-TTY
    

  • It is required to run interactive commands in a shell

• To list running containers:

  docker ps
  

5. Specific images

• The public repository called the Docker Hub contains a lot of ready-to-use images
• Some of the images contain a base OS:
  • Ubuntu
  • CentOS
  • Arch Linux
• Some contain compilers, interpreters or other useful tools:
  • Python
  • Maven
• Others contain known servers or DBMS:
  • Apache HTTP Server
  • PostgreSQL
• It is always a good idea to get acknowledged with the documentation of each specific image
• Creators of these images follow certain conventions to make the usage of image easier

6. Examples

• To run an HTTP server hosting a set of HTML files:

  echo '<h1>Hello World from Docker!</h1>' > index.html
  
  docker run -p 8080:80 -v "$(pwd):/usr/local/apache2/htdocs" httpd
  

  • The -p and -v flags stand for:

      -p, --publish list                   Publish a container's port(s) to the host
      -v, --volume list                    Bind mount a volume
    

  • The -p 8080:80 allows to bind localhost:8080 on the host system, to localhost:80 inside the container

  • The -v "$(pwd):/usr/local/apache2/htdocs" mounts the current directory on the host as /usr/local/apache2/htdocs inside the container

• To check if your Maven project builds correctly in a clean environment:

  mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart -DgroupId=pl.psnc -DartifactId=docker-training -Dversion=1.0.0 -DinteractiveMode=false
  
  docker run -v "$(pwd)/docker-training:/usr/src/docker-training" -w /usr/src/docker-training maven:3-openjdk-8 mvn package
  

  • The -v is used in a similar way as previously
  • The -w /usr/src/docker-training sets the working directory when the container launches
  • The image is maven:3-openjdk-8, to select specific OpenJDK version

• To start a PostgreSQL instance with a pre-defined schema and initial data:

  $ cat 1-init.sql
  CREATE TABLE data (
    id    SERIAL PRIMARY KEY,
    value INTEGER
  );
  
  $ cat 2-fill.sql
  INSERT INTO data (value) VALUES (100), (200), (300), (400), (500);
  
  docker run -e POSTGRES_PASSWORD=qwerty -v "$(pwd):/docker-entrypoint-initdb.d" -p 5432:5432 postgres
  

  • The -e POSTGRES_PASSWORD=qwerty sets value to an environment variable

  • The -v mounts the SQL scripts in a path loaded at runtime

  • The -p is used to publish the default PostgreSQL port from the container to the host

  • In another terminal, you can check if the database works correctly:

    • By executing a query inside the container:

      echo 'SELECT * FROM data' | docker exec -i sql-test psql --user postgres
      

      • docker exec allows to execute a command inside a running container
      • -i means that the standard input from the host (the SQL query) is passed to the process in the container

    • By executing a query in the host OS: (requires that you have psql command line tool available)

      echo 'SELECT * FROM data' | psql --host=localhost --username=postgres
      

7. Applications with multiple containers

• Keep the PostgreSQL container running

• Prepare the following index.php file:

  <?php
  $dbconn = pg_connect("host=localhost port=5432 user=postgres password=qwerty");
  $result = pg_query($dbconn, "SELECT id, value FROM data");
  
  echo "<table><thead><tr><th>Id</th><th>Value</th></tr></thead><tbody>";
  while ($row = pg_fetch_row($result)) {
      echo "<tr><td>$row[0]</td><td>$row[1]</td></tr>";
  }
  echo "</tbody></table>";
  ?>
  

  • The script will connect to the database, select all rows in the data table and create an HTML table with the result

• To run an Apache HTTP server with PHP:

  docker run -it -p 8080:80 -v "$(pwd):/var/www/html" php:apache sh -c 'apt-get update; apt-get install -y libpq-dev; docker-php-ext-install pgsql; apache2-foreground'
  

  • Take note that php:apache uses different default path than httpd image used
  • The command to be run in the container will (1) update packages list, (2) install libpq-dev, (3) install pgsql PHP extension and finally (4) run the HTTP server
  • This is not the optimal way of using the php:apache image; it would be better to build a new image on top of php:apache, but this will be covered in the next tutorial

• You can try opening http://localhost:8080, however you will only see a connection error

• The error appears because the PostgreSQL container is isolated

• It publishes its 5432 port to the host system, but not to the other containers

• To overcome this, let's create a Docker network:

  docker network create docker-training
  

• Restart the PostgreSQL container, but (1) put it into the docker-training network and (2) name it explicitly

  docker run -e POSTGRES_PASSWORD=qwerty -v "$(pwd):/docker-entrypoint-initdb.d" -p 5432:5432 --network docker-training --name db postgres
  

• Modify the index.php

  @@ -1,5 +1,5 @@
   <?php
  -$dbconn = pg_connect("host=localhost port=5432 user=postgres password=qwerty");
  +$dbconn = pg_connect("host=db port=5432 user=postgres password=qwerty");
   $result = pg_query($dbconn, "SELECT id, value FROM data");
  

• Restart the PHP container, but also put it into the docker-training network

  docker run -it -p 8080:80 -v "$(pwd):/var/www/html" --network docker-training php:apache sh -c 'apt-get update; apt-get install -y libpq-dev; docker-php-ext-install pgsql; apache2-foreground'
  

• Now you can see the result in http://localhost:8080

• Note that you can omit -p 5432:5432 when running PostgreSQL container unless you want to connect to database from the host

8. Docker Compose

• Running a multi-container application in the way described so far is tedious and error-prone

• To address such issues you can use Docker Compose

  • The whole application is described in a declarative YAML file
  • The file can be source-controlled in git or SVN and easily shared with others

• To recreate the previous application:

  • Create directories db and web

  • Copy 1-init.sql and 2-fill.sql to db/

  • Copy index.php to web/

  • Create the following docker-compose.yml file:

    version: "3.9"
    services:
      db:
        image: "postgres"
        environment:
          - POSTGRES_PASSWORD=qwerty
        volumes:
          - "./db:/docker-entrypoint-initdb.d"
      web:
        image: "php:apache"
        command: "sh -c 'apt-get update; apt-get install -y libpq-dev; docker-php-ext-install pgsql; apache2-foreground'"
        ports:
          - "8080:80"
        volumes:
          - "./web:/var/www/html"
    

• In this file you described db and web services

• By default Docker Compose will create a new Docker network and put both containers inside under these names

• Take note that in the volumes section you can use relative paths (command line Docker requires absolute paths)

• You can put into a git repository all files i.e. the db/ and web/ directories and the YAML file

• To run the Docker Compose application

  docker compose up
  

• Please note, that unlike docker run the containers started by Docker Compose are not destroyed but just stopped when you exit the above command

• This has consequences for certain images; for example, postgres image does not read /docker-entrypoint-initdb.d/ if it detects that there is a database already; if you start Docker Compose, then stop it to modify the initial SQL, then you need to run docker compose rm to enforce removal of containers and restart from scratch the next time