Docker.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "47a5a87a",
   "metadata": {},
   "source": [
    "<img src=\"./images/book.jpeg\" alt=\"drawing\" width=\"300\" align=\"left\"/>  \n",
    "<img src=\"./images/NigelPoulton.jpg\" alt=\"drawing\" width=\"314\" align=\"left\"/>  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8647cb84",
   "metadata": {},
   "source": [
    "**[Docker Deep Dive: Zero to Docker in a single book](https://www.amazon.com/gp/product/B01LXWQUFF/ref=dbs_a_def_rwt_bibl_vppi_i1)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e83387a",
   "metadata": {},
   "source": [
    "# Virtualization\n",
    "\n",
    "- **HW-Level Virtualization**  \n",
    "    - **Network Virtualization**  \n",
    "    - **Storage Virtualization**  \n",
    "    - **Server  Virtualization**  \n",
    "- **Application Virtualization**  \n",
    "- **OS-Level Virtualization**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a375899",
   "metadata": {},
   "source": [
    "# 1: Containers from a 30,000 feet"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32dff2ff",
   "metadata": {},
   "source": [
    "## The bad old days\n",
    "## Hello VMWare!\n",
    "## Hello Containers!\n",
    "- **Linux subsystems**  \n",
    "- **Mainframe**\n",
    "\n",
    "## Hello Docker!\n",
    "- **Docker, Inc. 1999**\n",
    "- **Windows Containers**  \n",
    "- **[Docker in GitHub](https://github.com/docker)**  \n",
    "\n",
    "## Windows containers vs Linux containers\n",
    "## What about Mac containers\n",
    "## What about Kubernetes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7d27606",
   "metadata": {},
   "source": [
    "---------"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf8a1b70",
   "metadata": {},
   "source": [
    "# 2: Docker"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bf0d69e",
   "metadata": {},
   "source": [
    "- **Docker, Inc. the company**  \n",
    "- **Docker the technology**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f1f358b",
   "metadata": {},
   "source": [
    "## Docker - The TLDR\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc3fb253",
   "metadata": {},
   "source": [
    "- **Software runs on Windows and Linux**  \n",
    "- **Create, Manage and Orchestrate containers**  \n",
    "- **Created by a companyn called Docker, Inc. in 1999**\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a90d78b",
   "metadata": {},
   "source": [
    "## Docker, Inc.\n",
    "<img src=\"./images/1.png\" alt=\"drawing\" width=\"300\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "937025c0",
   "metadata": {},
   "source": [
    "- **Was dotCloud**  \n",
    "- **Started as PaaS provider**  \n",
    "- **Build on Linux containers**  \n",
    "- **In 2013 Became Docker, Inc.\"**\n",
    "- **Two Main products:**\n",
    "    - **Docker Desktop**  \n",
    "    - **Docker Hub**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e61afa0d",
   "metadata": {},
   "source": [
    "## The Docker technology"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee39cd67",
   "metadata": {},
   "source": [
    "**Architecture**  \n",
    "<img src=\"./images/2.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21522d3a",
   "metadata": {},
   "source": [
    "**1. The runtime**  \n",
    "- ``runc``  \n",
    "    - Reference implementation of Open Containers Initiative (OCI) runtime-spec  \n",
    "    - Start/Stop containers  \n",
    "    - Build OS Constructs  \n",
    "- ``containerd``  \n",
    "    - Pull images  \n",
    "    - Create network interfaces  \n",
    "    - Manage runc  \n",
    "    - Open source project from CNCF  \n",
    "    \n",
    "**2. The daemon (a.k.a engine) ``dockerd``**  \n",
    "- Expose the Docker remote API  \n",
    "- Manage images  \n",
    "- Manage columes  \n",
    "- Manage netwroks  \n",
    "- etc.  \n",
    "\n",
    "**3. The orchestrator**  \n",
    "- Native support for managing clusters of nodes running Docker\n",
    "- Clusters of nodes running Docker are called swarm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf6cff08",
   "metadata": {},
   "source": [
    "## The Open Container Initiative (OCI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c95695cc",
   "metadata": {},
   "source": [
    "- **A governance council responsible for standardizing the low-level fundamental components of container infrastructure** \n",
    "- **Image formats. [image-spec](https://github.com/opencontainers/image-spec)**  \n",
    "- **container runtime. [runtime-spec](https://github.com/opencontainers/runtime-spec)**  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8fdb8f0",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4c4ec0b",
   "metadata": {},
   "source": [
    "# 3: Installing Docker"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "385fcfa8",
   "metadata": {},
   "source": [
    "- **Windows, Mac and Linux**  \n",
    "- **Local and Cloud**  \n",
    "- **Manual, Scripted and Wizard-based**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0b330f9",
   "metadata": {},
   "source": [
    "- Docker Desktop:  \n",
    "    * Windows 10  \n",
    "    * Mac  \n",
    "- Server installs:  \n",
    "    - Linux  \n",
    "    - Windows Server 2019  \n",
    "- Play with Docker  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60efeb7b",
   "metadata": {},
   "source": [
    "## Docker Desktop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c49063b",
   "metadata": {},
   "source": [
    "- Single-engine Docker \n",
    "- Docker Compose\n",
    "- Single-node Kubernetes cluster"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2355c22c",
   "metadata": {},
   "source": [
    "## Installing Docker on Linux"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e379de15",
   "metadata": {},
   "source": [
    "**[Install Docker Engine on Ubuntu](https://docs.docker.com/engine/install/ubuntu/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78a6af15",
   "metadata": {},
   "source": [
    "```\n",
    "$ sudo apt-get update\n",
    "$ sudo apt-get remove docker docker-engine docker.io containerd runc\n",
    "\n",
    "$ sudo apt-get update\n",
    "$ sudo apt-get install ca-certificates curl gnupg lsb-release\n",
    "\n",
    "$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg\n",
    "\n",
    "$ echo \\\n",
    "  \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \\\n",
    "  $(lsb_release -cs) stable\" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null\n",
    "\n",
    "\n",
    "$ sudo apt-get update --allow-unauthenticated --allow-insecure-repositories\n",
    "$ sudo apt-get install docker-ce docker-ce-cli containerd.io\n",
    "\n",
    "$ sudo docker --version\n",
    "$ sudo docker info\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a118f6a2",
   "metadata": {},
   "source": [
    "**[Play with Docker](https://labs.play-with-docker.com/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f4c08af1",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aef4df88",
   "metadata": {},
   "source": [
    "# 4: The Big Picture"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933a3a1b",
   "metadata": {},
   "source": [
    "## Quick overview on DevOps of the containers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f23ad30",
   "metadata": {},
   "source": [
    "### The Ops perspective"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b9056d6",
   "metadata": {},
   "source": [
    "- Download images\n",
    "- Start containers\n",
    "- Log in to containers\n",
    "- Run commands inside containers\n",
    "- List containers\n",
    "- etc."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a851de7b",
   "metadata": {},
   "source": [
    "#### Confirm Installation\n",
    "\n",
    "`$ sudo docker version`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58365f34",
   "metadata": {},
   "source": [
    "**note: you might need to add your user account to the local docker group rather than using \"sudo\" always**  \n",
    "- To check the current local groups:  \n",
    "    `$ sudo getent group`  \n",
    "- To check the groups you're currently in:  \n",
    "    `$ groups`  \n",
    "- To add a user to the local docker group:  \n",
    "    `$ sudo usermod -a -G docker <username>`  \n",
    "    `$ groups`  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "230c3f2f",
   "metadata": {},
   "source": [
    "#### Images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db240bf8",
   "metadata": {},
   "source": [
    "List all images  \n",
    "`$ docker image ls`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c38b7ca",
   "metadata": {},
   "source": [
    "Pull the `ubuntu:latest` image  \n",
    "`$ docker image pull ubuntu:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b824c0a3",
   "metadata": {},
   "source": [
    "Launch a container from an image  \n",
    "`$ docker container run -it ubuntu:latest /bin/bash`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10baac59",
   "metadata": {},
   "source": [
    "Exit a container without terminating it: `Ctrl-PQ`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f875325",
   "metadata": {},
   "source": [
    "Attach to a running container  \n",
    "`$ docker container exec -it <containername> bash`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "efd337d6",
   "metadata": {},
   "source": [
    "Stop a running container  \n",
    "`$ docker container stop <containername>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33e15744",
   "metadata": {},
   "source": [
    "Start a stopped container  \n",
    "`$ docker container start <containername>`  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89aeae9f",
   "metadata": {},
   "source": [
    "Delete a stopped container  \n",
    "`$ docker container rm <containername>`  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5f7f8d2",
   "metadata": {},
   "source": [
    "### The Dev perspective"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b5d5023",
   "metadata": {},
   "source": [
    "Clone a github repo that has a docker file  \n",
    "`$ git clone https://github.com/nigelpoulton/psweb.git`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "853261ac",
   "metadata": {},
   "source": [
    "Inspect the Dockerfile  \n",
    "`$ cat Dockerfile`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65ce55c2",
   "metadata": {},
   "source": [
    "Create a new image from the Dockerfile in the repo  \n",
    "Run the following command from inside the repo directory  \n",
    "`$ docker image build -t test:latest .`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f0e371d",
   "metadata": {},
   "source": [
    "List images after build. You should see 3 images (2 of them related to the newly built Dockerfile)  \n",
    "`$ docker image ls`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2e016bf",
   "metadata": {},
   "source": [
    "Launch a container from the test image  \n",
    "``` >\n",
    "$ docker container run -d \\\n",
    "  --name web1 \\\n",
    "  --publish 8080:8080 \\\n",
    "  test:latest\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bc1e1ab",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a67e2598",
   "metadata": {},
   "source": [
    "# 5: The Docker Engine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74e0c235",
   "metadata": {},
   "source": [
    "## Docker Engine - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa8bab3",
   "metadata": {},
   "source": [
    "<img src=\"./images/5.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72915ae7",
   "metadata": {},
   "source": [
    "### Docker Engine - The Deep Dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5924be82",
   "metadata": {},
   "source": [
    "<img src=\"./images/6.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "791d3284",
   "metadata": {},
   "source": [
    "### The influence of the Open Container Initiative (OCI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f444b790",
   "metadata": {},
   "source": [
    "#### **`runc`**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a88bf8c7",
   "metadata": {},
   "source": [
    "- CLI wrapper  \n",
    "- Only creates containers\n",
    "- Standalone container runtime tool\n",
    "- Also called \"the OCI layer\"\n",
    "- [`runc` lastest release information](https://github.com/opencontainers/runc/releases)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d8d469a",
   "metadata": {},
   "source": [
    "#### **`containerd`**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb11450e",
   "metadata": {},
   "source": [
    "- Backgroud process (`$ ps -elf | grep containerd`)\n",
    "- Manage container lifecycle(`start | stop | pause | rm ...`)\n",
    "- Image pulls, volumes, networks, etc.\n",
    "- Initially developed by Docker, Inc. then denoted to CNCF\n",
    "- [`containerd` latest release information](https://github.com/containerd/containerd/releases)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c58a2e5c",
   "metadata": {},
   "source": [
    "#### Starting a new container (example)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9712bfa0",
   "metadata": {},
   "source": [
    "`$ docker container run --name ctr1 -it alpine:latest sh`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53288982",
   "metadata": {},
   "source": [
    "1. Docker client converts it into appropriate API payload  \n",
    "2. POSTs it into API endpoint exposed by Docker daemon (`/var/run/docker.sock` on Linux)  \n",
    "3. Daemon calls `containerd`  \n",
    "4. `containerd` converts the required Docker image into an OCI bundle and uses `runc` to create the container  \n",
    "5. `runc` interfaces with the OS kernel to pull together all of th constructs necessary as a child-process of `runc`  \n",
    "6. After the child-process starts `runc` exits  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9a6cdd5",
   "metadata": {},
   "source": [
    "<img src=\"./images/7.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4354e952",
   "metadata": {},
   "source": [
    "**One huge benefit of this model**  \n",
    "- Container runtime is decoupled from the Docker daemon: \"daemonless containers\"  \n",
    "- You can perform maintenance and upgrades on the Docker daemon without impacting running containers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae65a98e",
   "metadata": {},
   "source": [
    "**What’s this shim all about?**  \n",
    "- Reduced version of `containerd` that remains running after `runc` exists after creating the container  \n",
    "- STDIN and STDOUT streams remain open even after the daemon is restarted  \n",
    "- Reports container status to daemon"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "354c9420",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "- `dockerd` (the Docker daemon)\n",
    "- `docker-containerd` (containerd)\n",
    "- `docker-containerd-shim` (shim)\n",
    "- `docker-runc` (runc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5550be8",
   "metadata": {},
   "source": [
    "`$ ps -elf | grep container`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc9f4eb2",
   "metadata": {},
   "source": [
    "**Securing client and daemon communication**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f4de571",
   "metadata": {},
   "source": [
    "Locally over IPC sockets:\n",
    "- `/var/run/docker.sock` on Linux  \n",
    "- `//./pipe/docker_engine` on Windows"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5779db5b",
   "metadata": {},
   "source": [
    "Over the network unsecure HTTP socket call on port `2375/tcp`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "974068e4",
   "metadata": {},
   "source": [
    "<img src=\"./images/8.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b400a2f9",
   "metadata": {},
   "source": [
    "**TLS can be enforced on both client and daemon**  \n",
    "1. Configure a CA and certificates \n",
    "2. Create a CA  \n",
    "3. Create and sign keys for the Daemon  \n",
    "4. Create and sign keys for the Client  \n",
    "5. Distribute keys  \n",
    "6. Configure Docker to use TLS  \n",
    "7. Configure daemon mode  \n",
    "8. Configure client mode  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90207851",
   "metadata": {},
   "source": [
    "**[Protect the Docker daemon socket](https://docs.docker.com/engine/security/protect-access/)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e41a592",
   "metadata": {},
   "source": [
    "<img src=\"./images/9.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "086e922e",
   "metadata": {},
   "source": [
    "<img src=\"./images/10.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d224f14",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2372546d",
   "metadata": {},
   "source": [
    "# 6: Images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bbcb245",
   "metadata": {},
   "source": [
    "## Docker images - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09535caf",
   "metadata": {},
   "source": [
    "- A unit of packaging that contains everything required for an application to run\n",
    "- Application code\n",
    "- Application dependencies\n",
    "- OS Constructs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f9e5a85",
   "metadata": {},
   "source": [
    "- In VM analogy an image is like a template VM (Stopped VM)\n",
    "- Get an image by \"Pulling\" it from a registry. By default Docker Hub is used\n",
    "- Consists of layers stacked on top of each other"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4665681b",
   "metadata": {},
   "source": [
    "## Docker images - The deep dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "101a200e",
   "metadata": {},
   "source": [
    "- Images are considered _build-time_ constructs where containers are _runtime_ constructs."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f8b5999",
   "metadata": {},
   "source": [
    "<img src=\"./images/11.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d612a832",
   "metadata": {},
   "source": [
    "### Images and containers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "754a5a7d",
   "metadata": {},
   "source": [
    "To start a container from an image  \n",
    "- `docker container run`  \n",
    "- `docker service create`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e63e3b7f",
   "metadata": {},
   "source": [
    "### Images are usually small"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c913010",
   "metadata": {},
   "source": [
    "- Images have _just enought operating system_  \n",
    "- They normally don't include kernel  \n",
    "- Some images are really small:  \n",
    "- [Alpine image in Docker Hub](https://hub.docker.com/_/alpine)  \n",
    "- [Alpine Linux](https://alpinelinux.org/downloads/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adceac6f",
   "metadata": {},
   "source": [
    "### Pulling images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dae3210",
   "metadata": {},
   "source": [
    "- Fresh installation of Docker comes with no images  \n",
    "- The local repo of Docker is in `/var/lib/docker/<storage-driver>`  \n",
    "- Use `docker image ls` to list all of the current images in the local repo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44b805bd",
   "metadata": {},
   "source": [
    "- Use `$ docker image pull redis:latest` to pull the latest redis image  \n",
    "- Use `$ docker image pull alpine:latest` to pull the latest alpine linux image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae66cf8f",
   "metadata": {},
   "source": [
    "### Image naming"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb26a2ed",
   "metadata": {},
   "source": [
    "**Image Registries**  \n",
    "- Images are stored in centralized places called _image registries_.  \n",
    "- The most common registry is [Docker Hub](https://hub.docker.com)  \n",
    "- Other 3rd party registries and local registries can also be used.\n",
    "- Use `$ docker info` to check the current \"Registry\" option.\n",
    "- Image registries contain one or more _image repositories_. Each repo can have one or more versions of the image."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87b85c76",
   "metadata": {},
   "source": [
    "<img src=\"./images/12.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b72b268b",
   "metadata": {},
   "source": [
    "### Official and unofficial repositories"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e56b9f38",
   "metadata": {},
   "source": [
    "- **_Official repositories_** are the home to images that have been vetted and curated by Docker, Inc.  \n",
    "- **_Unofficial repositories_** may not be safe, well-documented or built according to best practices."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c7fe13e",
   "metadata": {},
   "source": [
    "- _Official repos_ exist on the top level namespace in docker hub:\n",
    "    - nginx: https://hub.docker.com/_/nginx/\n",
    "    - busybox: https://hub.docker.com/_/busybox/\n",
    "    - redis: https://hub.docker.com/_/redis/\n",
    "    - mongo: https://hub.docker.com/_/mongo/\n",
    "- _Unofficial repos_ will have user account name in the url and not in the top level namespace:\n",
    "    - nigelpoulton/tu-demo — https://hub.docker.com/r/nigelpoulton/tu-demo/\n",
    "    - nigelpoulton/pluralsight-docker-ci — https://hub.docker.com/r/nigelpoulton/pluralsight-docker-ci/\n",
    "    - https://hub.docker.com/repository/docker/asami76/web"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71f9b1f3",
   "metadata": {},
   "source": [
    "### Image naming and tagging"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c02217d",
   "metadata": {},
   "source": [
    "**Pulling images from Official repos**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46e54e76",
   "metadata": {},
   "source": [
    "- `$ docker image pull <repository>:<tag>`  \n",
    "- `$ docker image pull alpine:latest`\n",
    "- `$ docker image pull mongo:4.2.6`\n",
    "- `$ docker image pull alpine`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db2332cd",
   "metadata": {},
   "source": [
    "**Pulling images from Unofficial repos**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1296e2c",
   "metadata": {},
   "source": [
    "- `$ docker image pull nigelpoulton/tu-demo:v2`  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02100f50",
   "metadata": {},
   "source": [
    "**Pulling images from 3rd party registries (not Docker Hub)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b4882f5",
   "metadata": {},
   "source": [
    "Pulling from `google-containers/git-sync` repo:  \n",
    "`$ docker image pull gcr.io/google-containers/git-sync:v3.1.5`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "330f6a53",
   "metadata": {},
   "source": [
    "### Images with multiple tags"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b52ed6e3",
   "metadata": {},
   "source": [
    "`$ docker image pull -a <imagename>` // will pull all versions of the image from the repo  \n",
    "`$ docker image prune` // remove all images that are not referenced by any container  \n",
    "`$ docker image prune -a` //remove all dangling images (images with no tags)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2479ac06",
   "metadata": {},
   "source": [
    "### Searching Docker Hub from the CLI"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8f7863d",
   "metadata": {},
   "source": [
    "- Use `docker search`  \n",
    "- `$ docker search nigelpoulton`\n",
    "- `$ docker search asami76`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "808cab8a",
   "metadata": {},
   "source": [
    "`--filter \"is-official=true\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03ee6409",
   "metadata": {},
   "source": [
    "- `$ docker search alpine --filter \"is-official=true\"`  \n",
    "- `$ docker search ubuntu --filter \"is-official=true\"`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60ec1555",
   "metadata": {},
   "source": [
    "### Images and layers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f6d0f0f",
   "metadata": {},
   "source": [
    "- A Docker image is a bunch of loosely-connected read-only layers.  \n",
    "- Each layer is one or more files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03160075",
   "metadata": {},
   "source": [
    "<img src=\"./images/13.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "04c9f43e",
   "metadata": {},
   "source": [
    "<img src=\"./images/15.png\" alt=\"drawing\" width=\"700\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38349cc1",
   "metadata": {},
   "source": [
    "<img src=\"./images/14.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ed7bf4b",
   "metadata": {},
   "source": [
    "Another way to see the layers of an image is to use `docker image inspect <image-name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4fffe58",
   "metadata": {},
   "source": [
    "`$ docker image inspect ubuntu:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56057428",
   "metadata": {},
   "source": [
    "- All Docker images start with a _base layer_  \n",
    "- New layers are added on top as new content is added to the image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cef6f987",
   "metadata": {},
   "source": [
    "**Example:**  \n",
    "Create a Python application on top over ubuntu 20.04 then some source code is added"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d7979c0",
   "metadata": {},
   "source": [
    "<img src=\"./images/16.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02f5a059",
   "metadata": {},
   "source": [
    "<img src=\"./images/17.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe833bf1",
   "metadata": {},
   "source": [
    "<img src=\"./images/18.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a59d7dac",
   "metadata": {},
   "source": [
    "**Docker uses a _storage driver_ in order to stack and merge all layers and present them as a single image.**  \n",
    "- `AUFS`, `overlay2`, `devicemapper`, `btrfs` and `zfs` for Linux\n",
    "- `windowsfilter` for Windows NTFS."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbf5ca78",
   "metadata": {},
   "source": [
    "<img src=\"./images/19.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b9e45e4",
   "metadata": {},
   "source": [
    "### Sharing image layers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "40db02b5",
   "metadata": {},
   "source": [
    "Multiple images can, and do, share layers. This leads to efficiencies in space and performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a3f02ee",
   "metadata": {},
   "source": [
    "`$ docker image pull -a nigelpoulton/tu-demo`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f59aa62",
   "metadata": {},
   "source": [
    "<img src=\"./images/20.png\" alt=\"drawing\" width=\"600\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "984d7f86",
   "metadata": {},
   "source": [
    "### Pulling images by digest"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f18ed6f",
   "metadata": {},
   "source": [
    "- What happens after you download an image with a tag and then the vendor uploads another image with the same tag?\n",
    "- Docker 1.10 introduced a content addressable storage model.\n",
    "-  As part of this model, all images get a _cryptographic content hash_.\n",
    "- This has is referred to as the _digest_.\n",
    "- Every time you pull an image, the `docker image pull` command includes the image’s digest as part of the information returned"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b69a3cec",
   "metadata": {},
   "source": [
    "- `$ docker image pull alpine`\n",
    "- `$ docker image ls --digests alpine`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8192ac10",
   "metadata": {},
   "source": [
    "- You can use the digest of the image when pulling it to ensure that we get **exactly the image we expect**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "463395eb",
   "metadata": {},
   "source": [
    "### A little bit more about image hashes (digests)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d36019b0",
   "metadata": {},
   "source": [
    "- The _image_ itself is a configuration file that lists the layers and some metadata.\n",
    "- The _layers_ are where the data lives (files, codes, etc.).\n",
    "- Each layer is independent.\n",
    "- Each image is identified by a crypto ID which is a hash of the config file.\n",
    "- Each layer is identified by a crypto ID which is a has of the contents (also called _content hashes_)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62fe9bb2",
   "metadata": {},
   "source": [
    "- If and image or a layer is changed the hash changes.\n",
    "- When pushing or pulling an image docker compresses the image to save network bandwidth - But this changes the hashes.\n",
    "- That's why each layer also has a **_distribution hash_** which is the hash of the image after compression."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "707dd243",
   "metadata": {},
   "source": [
    "### Multi-architecture images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6dcc39e2",
   "metadata": {},
   "source": [
    "- Windows and Linux, on variations of ARM, ARM 64, IBM Z, IBM POWER, x64, PowerPC, and s390x.\n",
    "- A single image tag supporting multiple platforms and architectures.\n",
    "- To make this happen, the Registry API supports two important constructs:\n",
    "    - **`manifest lists`**\n",
    "    - **`manifests`**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24c4e558",
   "metadata": {},
   "source": [
    "<img src=\"./images/21.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06bbca49",
   "metadata": {},
   "source": [
    "1. When pulling the image the Docker client makes a call to the Docker Registry API exposed by Docker Hub.\n",
    "2. Docker Registry API inspect the platform/Arch of the calling docker client.  \n",
    "3. If a **manifest list** exists for the image it will be parsed to see if there's a **manifest** for the calling client.\n",
    "4. If a **manifest** exists the API will retrieve the layers in it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa6275f0",
   "metadata": {},
   "source": [
    "**All official images have manifest lists.**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f72e08fe",
   "metadata": {},
   "source": [
    "`$ docker manifest inspect golang` // inspects manifest file on Docker Hub"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe87840b",
   "metadata": {},
   "source": [
    "To build an image for Linux/ARM:  \n",
    "`$ docker buildx build --platform linux/arm/v7 -t myimage:arm-v7`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2834746",
   "metadata": {},
   "source": [
    "To create your own manifest lists:  \n",
    "`docker manifest create`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa51f04f",
   "metadata": {},
   "source": [
    "### Deleting Images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "252aac08",
   "metadata": {},
   "source": [
    "`$ docker image rm <imagename or id>..<imagename or id>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9862f22b",
   "metadata": {},
   "source": [
    "Delete all images:  \n",
    "`$ docker image rm $(docker image ls -q) -f`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "232615ad",
   "metadata": {},
   "source": [
    "`$ docker image ls -q` // returns a list containing just the image IDs of all images pulled locally on the system"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "436108c7",
   "metadata": {},
   "source": [
    "## Images - The commands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8deb88f1",
   "metadata": {},
   "source": [
    "- `docker image pull` is the command to download images.  \n",
    "- `docker image ls` lists all of the images stored in your Docker host’s local image cache.  \n",
    "- `docker image inspect` all of the details of an image — layer data and metadata.  \n",
    "- `docker manifest inspect` allows you to inspect the manifest list of any image stored on Docker Hub.  \n",
    "- `docker buildx` is a Docker CLI plugin that extends the Docker CLI to support multi-arch builds.  \n",
    "- `docker image rm` is the command to delete images."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fe48ba5",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0464f6b4",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b3c1c53e",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e33731",
   "metadata": {},
   "source": [
    "# 7: Containers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49890912",
   "metadata": {},
   "source": [
    "**[Open Container Initiative (OCI)](https://www.opencontainers.org)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77f4b5aa",
   "metadata": {},
   "source": [
    "## Docker containers - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "351eb742",
   "metadata": {},
   "source": [
    "- A container is the runtime instance of an image.\n",
    "- Instead of running a full-blown OS like a VM, containers share the OS/kernel with the host they’re running on.\n",
    "- A single Docker image can be used to start multiple Docker containers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "718fa780",
   "metadata": {},
   "source": [
    "<img src=\"./images/22.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec9e5289",
   "metadata": {},
   "source": [
    "- `docker container run <image> <app>`\n",
    "- `$ docker container run -it ubuntu /bin/bash`\n",
    "- `$ docker container run -it alpine:latest sleep 10`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d93c340e",
   "metadata": {},
   "source": [
    "To stop the container:  \n",
    "`docker container stop`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da7d9b2f",
   "metadata": {},
   "source": [
    "To start the container:  \n",
    "`docker container start`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "325d0eab",
   "metadata": {},
   "source": [
    "To delete a container forever:  \n",
    "`docker container rm`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da5ff6e6",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6046bf66",
   "metadata": {},
   "source": [
    "## Docker containers - The deep dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a1f4c8e",
   "metadata": {},
   "source": [
    "### Containers vs VMs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed199f5",
   "metadata": {},
   "source": [
    "**VMs Architecture**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a114858",
   "metadata": {},
   "source": [
    "<img src=\"./images/23.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33a89a96",
   "metadata": {},
   "source": [
    "**Containers Architecture**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4d16e02",
   "metadata": {},
   "source": [
    "<img src=\"./images/24.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "075466b4",
   "metadata": {},
   "source": [
    "- Hypervisors perform **hardware virtualization** — they carve up physical hardware resources into virtual versions called VMs.\n",
    "- Containers perform **OS virtualization** — they carve OS resources into virtual versions called containers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fac6f99",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "994c5d42",
   "metadata": {},
   "source": [
    "### The VM tax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6a27e42",
   "metadata": {},
   "source": [
    "- Less resources\n",
    "- Less licenses\n",
    "- Faster\n",
    "- Single kerner, single surface of attack"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67fbf7e9",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4cc18400",
   "metadata": {},
   "source": [
    "### Running containers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "522b08fb",
   "metadata": {},
   "source": [
    "- Docker Desktop on Mac or Windows\n",
    "- docker.io on Linux"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4590a193",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "28741895",
   "metadata": {},
   "source": [
    "### Checking that Docker is running"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8557dce6",
   "metadata": {},
   "source": [
    "`$ sudo docker version`"
   ]
  },
  {
   "cell_type": "raw",
   "id": "9b2ee7ef",
   "metadata": {},
   "source": [
    "Client:\n",
    " Version:           20.10.7\n",
    " API version:       1.41\n",
    " Go version:        go1.13.8\n",
    " Git commit:        20.10.7-0ubuntu5.1\n",
    " Built:             Mon Nov  1 00:33:40 2021\n",
    " OS/Arch:           linux/amd64\n",
    " Context:           default\n",
    " Experimental:      true\n",
    "\n",
    "Server:\n",
    " Engine:\n",
    "  Version:          20.10.7\n",
    "  API version:      1.41 (minimum version 1.12)\n",
    "  Go version:       go1.13.8\n",
    "  Git commit:       20.10.7-0ubuntu5.1\n",
    "  Built:            Thu Oct 21 23:58:58 2021\n",
    "  OS/Arch:          linux/amd64\n",
    "  Experimental:     false\n",
    " containerd:\n",
    "  Version:          1.5.5-0ubuntu3\n",
    "  GitCommit:        \n",
    " runc:\n",
    "  Version:          1.0.1-0ubuntu2\n",
    "  GitCommit:        \n",
    " docker-init:\n",
    "  Version:          0.19.0\n",
    "  GitCommit:        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e26dd4cf",
   "metadata": {},
   "source": [
    "To check the current local groups:  \n",
    "`$ sudo getent group`  \n",
    "To check the groups you're currently in:  \n",
    "`$ groups`  \n",
    "To add a user to the local docker group:  \n",
    "`$ sudo usermod -a -G docker <username>`  \n",
    "`$ groups`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a49888f",
   "metadata": {},
   "source": [
    "Check service status:  \n",
    "`$ service docker status`  \n",
    "`$ systemctl is-active docker`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87ca2ce0",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "41965e63",
   "metadata": {},
   "source": [
    "### Starting a simple container"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5306c085",
   "metadata": {},
   "source": [
    "`$ docker container run -it ubuntu:latest`  \n",
    "1. Docker client POSTs the request to Docker API on local socket `/var/run/docker.sock`  \n",
    "2. Docker daemon checks the local repo for the `ubuntu:latest` image, if it's not their it will check Docker Hub.\n",
    "3. After obtaining the image it instructs `containerd` and 'runc' to create and run the container."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b91d8b5",
   "metadata": {},
   "source": [
    "- `-i` run container in interactive mode keeping STDIN stream open  \n",
    "- `-t` Allocate a pseudo-TTY  \n",
    "- `/bin/bash` this makes Bash shell **one and only process running inside of the container**. Run `ps -elf` to validate.\n",
    "- `root@50949b614477:/#` container pseudo terminal"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aaeac5ac",
   "metadata": {},
   "source": [
    "### Container processes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa9ebb6c",
   "metadata": {},
   "source": [
    "- `/bin/bash` is the only process running in the container, hence if you run `exit` it will exit and terminate the container.\n",
    "- If you run `Ctrl-PQ` it will exist the container without terminating it.\n",
    "- **killing the main process in the container will kill the container**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81f21ad6",
   "metadata": {},
   "source": [
    "### Container lifecycle"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "417bd157",
   "metadata": {},
   "source": [
    "**Change the name of the running container**  \n",
    "`$ docker container run --name sawsan -it ubuntu:latest /bin/bash`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26757c26",
   "metadata": {},
   "source": [
    "**Write data to container**  \n",
    "`# cd tmp`   \n",
    "`# echo \"Jan 25th, the day Egypt stood still\" > newfile`  \n",
    "`# ls -l`  \n",
    "`# cat newfile`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26b79285",
   "metadata": {},
   "source": [
    "**Stop containers**  \n",
    "`docker container stop <container-id or container-name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "878720a7",
   "metadata": {},
   "source": [
    "**Start containers**  \n",
    "`docker container start <container-name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c47a36b",
   "metadata": {},
   "source": [
    "**Start containers in detached mode (run it in the background)**  \n",
    "`docker container run -d <container-name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "811512a2",
   "metadata": {},
   "source": [
    "**Connect to running container**  \n",
    "`docker container exec -it <container-name> bash`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a9175fe",
   "metadata": {},
   "source": [
    "**Try to access the text file created (newfile) after restarting and reconnecting to the container**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c51ff2bd",
   "metadata": {},
   "source": [
    "**Notes**  \n",
    "1. The data created in this example is stored on the Docker hosts local filesystem. If the Docker host fails, the data will be lost.  \n",
    "2. Containers are designed to be immutable objects and it’s not a good practice to write data to them"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3aaa299e",
   "metadata": {},
   "source": [
    "**Kill a running container**  \n",
    "- In one step:\n",
    "    - `docker container rm -f <container-name>`\n",
    "- In two steps:\n",
    "    - `docker container stop <container-name>`\n",
    "    - `docker container rm <container-name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d91ce7",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6d6126dc",
   "metadata": {},
   "source": [
    "### Stopping containers gracefully"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "809c6b6f",
   "metadata": {},
   "source": [
    "- `docker container stop` sends a **SIGTERM** signal to PID(1)\n",
    "- If the process doesn't exit in 10 sec it sends a **SIGKILL** signal  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2bb85df6",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e3e60230",
   "metadata": {},
   "source": [
    "### Self-healing containers with restart policies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14735caa",
   "metadata": {},
   "source": [
    "Restart policies are applied per-container, and can be configured imperatively on the command line as part of `docker container run` commands, or declaratively in YAML files for use with higher-level tools"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "630650dd",
   "metadata": {},
   "source": [
    "**`always`**  \n",
    "container will always restart if the main process is killed from inside the container but won't restart if you manually stopped it. Will restart if the Docker daemon restarts.  \n",
    "**`unless-stopped`**  \n",
    "container will always restart if the main process is killed from inside the container but won't restart if you manually stopped it. However will NOT restart if the Docker daemon restarts.  \n",
    "**`on-failue`**  \n",
    "container will always restart if the main process exits with non-zero code (i.e. with error) but won't restart if you manually stopped it. However will restart if the Docker daemon restarts.  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "851be20e",
   "metadata": {},
   "source": [
    "`docker container run --name <container-name> --restart always <image-name> <process>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "764c5557",
   "metadata": {},
   "source": [
    "1. `$ docker container run --name neversaydie -it --restart always alpine sh`\n",
    "2. `# exit`\n",
    "3. `$ docker container ls`\n",
    "4. `$ docker container inspect neversaydie`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7692f875",
   "metadata": {},
   "source": [
    "check the `RestartCount` item in the inspection json."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c5d3600",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d50944ce",
   "metadata": {},
   "source": [
    "### Web server example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "462003a8",
   "metadata": {},
   "source": [
    "1. `$ docker container run -d --name webserver -p 80:80 nginx:latest`\n",
    "2. open browser http://localhost:80\n",
    "3. stop the container \n",
    "4. open browser again and refresh\n",
    "5. start the container\n",
    "6. open browser again and refresh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d00fced",
   "metadata": {},
   "source": [
    "### SQL Example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c9e703",
   "metadata": {},
   "source": [
    "**[Docker Hub - Microsoft SQL Server Repo](https://hub.docker.com/_/microsoft-mssql-server)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf565f92",
   "metadata": {},
   "source": [
    "`$ docker run -e \"ACCEPT_EULA=Y\" -e \"SA_PASSWORD=P@ssw0rd\" -e \"MSSQL_PID=Express\" -p 1433:1433 -d mcr.microsoft.com/mssql/server:2019-latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "994e4a12",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "41b9c654",
   "metadata": {},
   "source": [
    "### Inspecting containers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac374093",
   "metadata": {},
   "source": [
    "- When building a Docker image, you can embed an instruction that lists the default app for any containers that use the image. You can see this for any image by running a `docker image inspect`  \n",
    "- `Cmd` show the command/app that the container will run unless you override it with a different one when you launch the container with `docker container run`\n",
    "- sometimes the default app is listed as `Entrypoint` instead of `Cmd`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14545ef9",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "077a1764",
   "metadata": {},
   "source": [
    "### Tidying up"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c923c12",
   "metadata": {},
   "source": [
    "Delete all containers by force  \n",
    "`$ docker container rm $(docker container ls -aq) -f`  \n",
    "Delete all images by force  \n",
    "`$ docker image rm $(docker image ls -q) -f`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bd16862",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "222e112f",
   "metadata": {},
   "source": [
    "## Containers - The commands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25920c9a",
   "metadata": {},
   "source": [
    "- `docker container run`  // start new containers.\n",
    "- `docker container run -it ubuntu /bin/bash`\n",
    "- `Ctrl-PQ`  // will detach your shell from the terminal of a container and leave the container running (UP) in the background.\n",
    "- `docker container ls`  // lists all containers in the running (UP). Add -a flag to list (Existed) containers.\n",
    "- `docker container exec`  // runs a new process inside of a running container.\n",
    "- `docker container stop`  // stop a running container and put it in the Exited (0) state.\n",
    "- `docker container start`  // will restart a stopped (Exited) container.\n",
    "- `docker container rm`  // delete a stopped container.\n",
    "- `docker container stop`  // stops a running (UP) container .\n",
    "- `docker container inspect`  // will show you detailed configuration and runtime information about a container."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "009649c5",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4af443b1",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a25ac758",
   "metadata": {},
   "source": [
    "# 8: Containerizing an App"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad83b87b",
   "metadata": {},
   "source": [
    "The process of taking an application and configuring it to run as a container is called “containerizing\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4edd6334",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "193a990b",
   "metadata": {},
   "source": [
    "## Containerizing an app - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d45fc771",
   "metadata": {},
   "source": [
    "The process of containerizing an app looks like this:\n",
    "\n",
    "1. Start with your application code and dependencies\n",
    "2. Create a _Dockerfile_ that describes your app, its dependencies, and how to run it\n",
    "3. Feed the _Dockerfile_ into the `docker image build` command\n",
    "4. Push the new image to a registry (optional)\n",
    "5. Run container from the image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa1b376d",
   "metadata": {},
   "source": [
    "<img src=\"./images/25.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d6d94db",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d21990e7",
   "metadata": {},
   "source": [
    "## Containerizing an app - The deep dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5879bf8",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b445179c",
   "metadata": {},
   "source": [
    "### Containerize a single-container app"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb02ba9",
   "metadata": {},
   "source": [
    "- Clone the repo to get the app code\n",
    "- Inspect the Dockerfile\n",
    "- Containerize the app\n",
    "- Run the app\n",
    "- Test the app\n",
    "- Look a bit closer\n",
    "- Move to production with Multi-stage Builds\n",
    "- A few best practices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ba2b4d7",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6cd7ca56",
   "metadata": {},
   "source": [
    "#### Getting the application code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a9f277c",
   "metadata": {},
   "source": [
    "`$ git clone https://github.com/nigelpoulton/psweb.git`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ac84163",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9192802e",
   "metadata": {},
   "source": [
    "#### Inspecting the Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75831571",
   "metadata": {},
   "source": [
    "1. All Dockerfiles start with the `FROM` instruction. This will be the base layer of the image, and the rest of the app will be added on top as additional layers."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd354cab",
   "metadata": {},
   "source": [
    "<img src=\"./images/26.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eda021a1",
   "metadata": {},
   "source": [
    "2. Next, the Dockerfile creates a `LABEL` that specifies “nigelpoulton@hotmail.com” as the maintainer of the image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56cf5129",
   "metadata": {},
   "source": [
    "3. The `RUN apk add --update nodejs nodejs-npm` instruction uses the Alpine `apk` package manager to install `nodejs` and `nodejs-npm` into the image."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9fbad6f",
   "metadata": {},
   "source": [
    "<img src=\"./images/27.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0562bdb0",
   "metadata": {},
   "source": [
    "4. The `COPY . /src` instruction creates another new layer and copies in the application and dependency files from the _build context_."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05e48133",
   "metadata": {},
   "source": [
    "<img src=\"./images/28.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eef14283",
   "metadata": {},
   "source": [
    "5. Next, the Dockerfile uses the `WORKDIR` instruction to set the working directory inside the image filesystem for the rest of the instructions in the file"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a15efc0a",
   "metadata": {},
   "source": [
    "6. Then the `RUN npm install` instruction creates a new layer and uses `npm` to install application dependencies listed in the `package.json` file in the build context."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deb33aed",
   "metadata": {},
   "source": [
    "<img src=\"./images/29.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbb66e72",
   "metadata": {},
   "source": [
    "7. The application exposes a web service on TCP port 8080, so the Dockerfile documents this with the `EXPOSE 8080` instruction."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c374816a",
   "metadata": {},
   "source": [
    "8. Finally, the `ENTRYPOINT` instruction is used to set the main application that the image (container) should run. This is also added as metadata and not an image layer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df9a5003",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2e52ab3e",
   "metadata": {},
   "source": [
    "#### Containerize the app/build the image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "264cbdd4",
   "metadata": {},
   "source": [
    "`$ docker image build -t web:latest .`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2365c91",
   "metadata": {},
   "source": [
    "`$ docker images`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce5016e2",
   "metadata": {},
   "source": [
    "`$ docker image inspect web:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c61e497c",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "57c7efa2",
   "metadata": {},
   "source": [
    "#### Pushing images"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "796467bc",
   "metadata": {},
   "source": [
    "First login to the Docker Hub registry:  \n",
    "`docker login`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "021036c8",
   "metadata": {},
   "source": [
    "Docker needs the following information when pushing an image:\n",
    "- `Registry`\n",
    "- `Repository`\n",
    "- `Tag`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abd07403",
   "metadata": {},
   "source": [
    "The `tag` should include the `repository` name (your user account on Docker Hub):  \n",
    "`$ docker image tag <current-tag> <repository-name>/<new-tag>`  \n",
    "`$ docker image tag web:latest asami76/newweb:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b01b908b",
   "metadata": {},
   "source": [
    "`$ docker image push asami76/newweb:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5c9f3dd",
   "metadata": {},
   "source": [
    "<img src=\"./images/30.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "157f4037",
   "metadata": {},
   "source": [
    "You can also create multiple image tags and push them to the same repo:  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14d80199",
   "metadata": {},
   "source": [
    "`$ docker image tag web:latest asami76/newweb:v2`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00a1fce4",
   "metadata": {},
   "source": [
    "Check the following URL to find all of the tags in the `newweb` repo  \n",
    "**[asami76/newweb](https://hub.docker.com/repository/docker/asami76/newweb)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8aa12df",
   "metadata": {},
   "source": [
    "#### Run the app"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ced3e691",
   "metadata": {},
   "source": [
    "Remove all images from the local repo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7336aea1",
   "metadata": {},
   "source": [
    "Run the following command to create a container named c1 based on the image we just pushed:  \n",
    " `$ docker container run -d --name c1 -p 80:8080 asami76/newweb:latest`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "629cf7cb",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d177a103",
   "metadata": {},
   "source": [
    "#### Test the app"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd6be946",
   "metadata": {},
   "source": [
    "Open the browser in the Docker Host on URL http://localhost:80"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f1275ca",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "24173616",
   "metadata": {},
   "source": [
    "#### Looking a bit closer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65b63a40",
   "metadata": {},
   "source": [
    "The `docker image build` command parses the Dockerfile one-line-at-a-time starting from the top."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b43acb7b",
   "metadata": {},
   "source": [
    "Comment lines start with the `#` character."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "243ca40a",
   "metadata": {},
   "source": [
    "**Instructions** and take the format `INSTRUCTION argument`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a49d4313",
   "metadata": {},
   "source": [
    "View the instructions that were used to build the image with the `docker image history` command."
   ]
  },
  {
   "cell_type": "raw",
   "id": "53ce33a7",
   "metadata": {},
   "source": [
    "$ docker image history web:latest\n",
    "\n",
    "IMAGE     CREATED BY                                      SIZE\n",
    "fc6..18e  /bin/sh -c #(nop)  ENTRYPOINT [\"node\" \"./a...   0B\n",
    "334..bf0  /bin/sh -c #(nop)  EXPOSE 8080/tcp              0B\n",
    "b27..eae  /bin/sh -c npm install                          14.1MB\n",
    "932..749  /bin/sh -c #(nop) WORKDIR /src                  0B\n",
    "052..2dc  /bin/sh -c #(nop) COPY dir:2a6ed1703749e80...   22.5kB\n",
    "c1d..81f  /bin/sh -c apk add --update nodejs nodejs-npm   46.1MB\n",
    "336..b92  /bin/sh -c #(nop)  LABEL maintainer=nigelp...   0B\n",
    "3fd..f02  /bin/sh -c #(nop)  CMD [\"/bin/sh\"]              0B\n",
    "<missing> /bin/sh -c #(nop) ADD file:093f0723fa46f6c...   4.15MB"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7d8b463",
   "metadata": {},
   "source": [
    "- Each line corresponds to an instruction in the Dockerfile (starting from the bottom and working up).  \n",
    "- The CREATED BY column even lists the exact Dockerfile instruction that was executed.  \n",
    "- Only 4 of the lines displayed in the output create new layers (the ones with non-zero values in the SIZE column)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2969d16",
   "metadata": {},
   "source": [
    "The `docker image build` executes in the following order:  \n",
    "`spin up a temporary container` > `run the Dockerfile instruction inside of that container` > `save the results as a new image layer` > `remove the temporary container`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef5e6f39",
   "metadata": {},
   "source": [
    "**[Dockerfile Instructions Cheatsheet](https://medium.com/@oap.py/dockerfile-cheat-sheet-4ad12569aa0b)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9986d1dd",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5f207817",
   "metadata": {},
   "source": [
    "### Moving to production with Multi-stage Builds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d970b11",
   "metadata": {},
   "source": [
    "Multi-stage builds have a single Dockerfile containing multiple FROM instructions. Each FROM instruction is a new **build stage** that can easily COPY artefacts from previous **stages**."
   ]
  },
  {
   "cell_type": "raw",
   "id": "e5b8ef79",
   "metadata": {},
   "source": [
    "FROM node:latest AS storefront\n",
    "WORKDIR /usr/src/atsea/app/react-app\n",
    "COPY react-app .\n",
    "RUN npm install\n",
    "RUN npm run build\n",
    "\n",
    "FROM maven:latest AS appserver\n",
    "WORKDIR /usr/src/atsea\n",
    "COPY pom.xml .\n",
    "RUN mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:resolve\n",
    "COPY . .\n",
    "RUN mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests\n",
    "\n",
    "FROM java:8-jdk-alpine AS production\n",
    "RUN adduser -Dh /home/gordon gordon\n",
    "WORKDIR /static\n",
    "COPY --from=storefront /usr/src/atsea/app/react-app/build/ .\n",
    "WORKDIR /app\n",
    "COPY --from=appserver /usr/src/atsea/target/AtSea-0.0.1-SNAPSHOT.jar .\n",
    "ENTRYPOINT [\"java\", \"-jar\", \"/app/AtSea-0.0.1-SNAPSHOT.jar\"]\n",
    "CMD [\"--spring.profiles.active=postgres\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c14e8ec5",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2fe32314",
   "metadata": {},
   "source": [
    "### A few best practices"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc97ff7e",
   "metadata": {},
   "source": [
    "#### Leverage the build cache"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08ea9851",
   "metadata": {},
   "source": [
    "Artefacts from the first build, such as layers, are cached and leveraged by later builds."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7dc2bc5",
   "metadata": {},
   "source": [
    "During the `docker image build` and for each instruction in the Dockerfile, Docker looks to see if it already has an image layer for that instruction in its cache. If it does, this is a _cache hit_ and it uses that layer. If it doesn’t, this is a _cache miss_ and it builds a new layer from the instruction."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e11f789b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8554aca9",
   "metadata": {},
   "source": [
    "#### Squash the image"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1287aa95",
   "metadata": {},
   "source": [
    "Squashing an image means that after building the image all layers will be merged(squashed) into a single layer."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97afef2e",
   "metadata": {},
   "source": [
    "Add the `--squash` flag to the `docker image build` command if you want to create a squashed image."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c54a159",
   "metadata": {},
   "source": [
    "<img src=\"./images/31.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54da3b60",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "18b0e312",
   "metadata": {},
   "source": [
    "#### Use no-install-recommends"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ed3bed1",
   "metadata": {},
   "source": [
    "- `no-install-recommends` flag with the `apt-get` install command.\n",
    "- This makes sure that apt only installs main dependencies (packages in the Depends field) and not recommended or suggested packages."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a365de3",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "67f60025",
   "metadata": {},
   "source": [
    "## Containerizing an app - The commands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97aabf9b",
   "metadata": {},
   "source": [
    "- `docker image build` // the command that reads a Dockerfile and containerizes an application\n",
    "- Dockerfile instructions:\n",
    "    - `FROM`  // specifies the base image for the new image you will build. It is usually the first instruction in a Dockerfile\n",
    "    - `RUN`  // run commands inside the image. Each RUN instruction creates a single new layer.\n",
    "    - `COPY`  // adds files into the image as a new layer. It is common to use the COPY instruction to copy your application code into an image.\n",
    "    - `EXPOSE`  // documents the network port that the application uses.\n",
    "    - `ENTRYPOINT`  // sets the default application to run when the image is started as a container.\n",
    "    - Other Dockerfile instructions include LABEL, ENV, ONBUILD, HEALTHCHECK, CMD and more…"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "815a9a3e",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "fe4181b1",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1956118",
   "metadata": {},
   "source": [
    "# 9: Deploying Apps with Docker Compose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c60547",
   "metadata": {},
   "source": [
    "## Deploying apps with Compose - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66dfa237",
   "metadata": {},
   "source": [
    "“microservices”. A simple example might be an app with the following seven services:\n",
    "\n",
    "- Web front-end\n",
    "- Ordering\n",
    "- Catalog\n",
    "- Back-end database\n",
    "- Logging\n",
    "- Authentication\n",
    "- Authorization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c20c3a32",
   "metadata": {},
   "source": [
    "**Docker Compose** lets you describe an entire app in a single declarative configuration file, and deploy it with a single command"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a053a9da",
   "metadata": {},
   "source": [
    "## Deploying apps with Compose - The Deep Dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "714fe94e",
   "metadata": {},
   "source": [
    "### Compose background"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a34b8eef",
   "metadata": {},
   "source": [
    "- Fig was a powerful Python tool, created by a company called Orchard, let you define entire multi-container apps in a single YAML file.\n",
    "- Docker, Inc. acquired Orchard and re-branded Fig as Docker Compose.\n",
    "- In April 2020 announced open standard for defining multi-container cloud-native apps."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1de0d7ce",
   "metadata": {},
   "source": [
    "**[Compse Specficiation](https://github.com/compose-spec/compose-spec)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a4a8167",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "01864b3d",
   "metadata": {},
   "source": [
    "### Installing Compose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1ff67e51",
   "metadata": {},
   "source": [
    "Windows and Mac: Part of Docker Desktop"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "113fc8f1",
   "metadata": {},
   "source": [
    "#### Installing Compose on Linux"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0431ec23",
   "metadata": {},
   "source": [
    "1. Download the binary using the curl command.\n",
    "2. Make it executable using chmod"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a68ee34",
   "metadata": {},
   "source": [
    "**[docker-compose repo in GitHub](https://github.com/docker/compose/releases)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7c69bae",
   "metadata": {},
   "source": [
    "`$ sudo curl -L \\\n",
    "https://github.com/docker/compose/releases/download/v2.2.3/docker-compose-linux-x86_64 \\\n",
    "-o /usr/local/bin/docker-compose`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b607203",
   "metadata": {},
   "source": [
    "`$ sudo chmod +x /usr/local/bin/docker-compose`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54d4c526",
   "metadata": {},
   "source": [
    "`$ docker-compose --version`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ded5a96e",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ea966a4e",
   "metadata": {},
   "source": [
    "### Compose files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d09fbc8c",
   "metadata": {},
   "source": [
    "- Compose uses YAML files to define multi-service applications. \n",
    "- YAML is a subset of JSON, so you can also use JSON. \n",
    "- The default name for a Compose YAML file is `docker-compose.yml`."
   ]
  },
  {
   "cell_type": "raw",
   "id": "4289689b",
   "metadata": {},
   "source": [
    "version: \"3.8\"\n",
    "services:\n",
    "  web-fe:\n",
    "    build: .\n",
    "    command: python app.py\n",
    "    ports:\n",
    "      - target: 5000\n",
    "        published: 5000\n",
    "    networks:\n",
    "      - counter-net\n",
    "    volumes:\n",
    "      - type: volume\n",
    "        source: counter-vol\n",
    "        target: /code\n",
    "  redis:\n",
    "    image: \"redis:alpine\"\n",
    "    networks:\n",
    "      counter-net:\n",
    "\n",
    "networks:\n",
    "  counter-net:\n",
    "\n",
    "volumes:\n",
    "  counter-vol:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "122f7f4e",
   "metadata": {},
   "source": [
    "Four top-level keys:\n",
    "- `version`\n",
    "- `services`\n",
    "- `networks`\n",
    "- `volumes`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e6d152a",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7a49fef0",
   "metadata": {},
   "source": [
    "### Deploying an app with Compose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4720269b",
   "metadata": {},
   "source": [
    "`$ git clone https://github.com/nigelpoulton/counter-app.git`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "849fbf85",
   "metadata": {},
   "source": [
    "Inspect the files"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d8c84c7",
   "metadata": {},
   "source": [
    "Build the App:  \n",
    "`$ docker-compose up &`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "634d19df",
   "metadata": {},
   "source": [
    "The multi-container app defined in a Compose file is called a _Compose app_."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e17ff57d",
   "metadata": {},
   "source": [
    "`docker-compose up` expects the name of the Compose file to `docker-compose.yml`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "404e108d",
   "metadata": {},
   "source": [
    "Or use the `-f` flag to specify a different compose file name:  \n",
    "`$ docker-compose -f prod-equus-bass.yml up`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b57043c0",
   "metadata": {},
   "source": [
    "We can see that three images were either built or pulled as part of the deployment."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e80bcb5d",
   "metadata": {},
   "source": [
    "Run the container in a browser"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39a5835f",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d6824e23",
   "metadata": {},
   "source": [
    "### Managing an app with Compose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de98c9e0",
   "metadata": {},
   "source": [
    "start, stop, delete, and get the status of applications being managed by Docker Compose"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bf2fa33",
   "metadata": {},
   "source": [
    "To stop and remove all containers in an App  \n",
    "`$ docker-compose down`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49c98771",
   "metadata": {},
   "source": [
    "`counter-net` network removed  \n",
    "`counter-vol` volume NOT rmeoved (persistent)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2d6eb85",
   "metadata": {},
   "source": [
    "To start the App in the background `-d`  \n",
    "`$ docker-compose up -d`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b29c08a8",
   "metadata": {},
   "source": [
    "To list the processes running inside of each service (container)  \n",
    "`$ docker-compose top`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfa621fa",
   "metadata": {},
   "source": [
    "To stop the app without deleting its resources  \n",
    "`$ docker-compose stop`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9edb66f4",
   "metadata": {},
   "source": [
    "To delete a stopped Compose app  \n",
    "`$ docker-compose rm`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10b2abf0",
   "metadata": {},
   "source": [
    "To Restart the app  \n",
    "`$ docker-compose restart`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ea43295",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5e9caf76",
   "metadata": {},
   "source": [
    "## Deploying apps with Compose - The commands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa2f0461",
   "metadata": {},
   "source": [
    "- `docker-compose up`  // deploy a Compose app.\n",
    "- `docker-compose stop`  // stop all of the containers in a Compose app without deleting them from the system.\n",
    "- `docker-compose rm`  // delete a stopped Compose app.\n",
    "- `docker-compose restart`  // restart a Compose app that has been stopped with docker-compose stop.\n",
    "- `docker-compose ps`  // list each container in the Compose app.\n",
    "- `docker-compose down`  // stop and delete a running Compose app. It deletes containers and networks, but not volumes and images."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53831738",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "465791ad",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2777e63",
   "metadata": {},
   "source": [
    "# 10: Docker Swarm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42fa66f6",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f37df199",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2aedf630",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "60291cb2",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "467ab368",
   "metadata": {},
   "source": [
    "# 11: Docker Networking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "956dd771",
   "metadata": {},
   "source": [
    "## Docker Networking - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9eeea2c7",
   "metadata": {},
   "source": [
    "- container-to-container\n",
    "- continer to other network\n",
    "- container to VLAN"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8881798",
   "metadata": {},
   "source": [
    "- Docker networking is based on open-source Container Network Model (CNM).\n",
    "- `libnetwork` is Docker's implementation of CNM.\n",
    "    - single-host bridge networks\n",
    "    - multi-host overlays\n",
    "    - plugins for existing VLANs\n",
    "    - native service discovery\n",
    "    - basic container load balancing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c15866f",
   "metadata": {},
   "source": [
    "## Docker Networking - The Deep Dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b55bd07f",
   "metadata": {},
   "source": [
    "### The theory"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef797bbc",
   "metadata": {},
   "source": [
    "Docker networking components:\n",
    "- The Container Network Model (CNM)\n",
    "- libnetwork\n",
    "- Drivers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f88042ec",
   "metadata": {},
   "source": [
    "<img src=\"./images/32.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c96b9dd3",
   "metadata": {},
   "source": [
    "### The Container Network Model (CNM)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60da3cc0",
   "metadata": {},
   "source": [
    "**[CNM Design Specifications on GitHub](https://github.com/docker/libnetwork/blob/master/docs/design.md)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2eb6f8e",
   "metadata": {},
   "source": [
    "CNM Building Blocks:\n",
    "- **Sandboxes**: an isolated network stack. It includes; Ethernet interfaces, ports, routing tables, and DNS config.\n",
    "- **Endpoints**: virtual network interfaces responsible for making sandboxes connect to networks.\n",
    "- **Networks**: software implementation of an switch (802.1d bridge)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0454342",
   "metadata": {},
   "source": [
    "<img src=\"./images/33.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b4dd977",
   "metadata": {},
   "source": [
    "<img src=\"./images/34.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a0932b9",
   "metadata": {},
   "source": [
    "<img src=\"./images/35.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d94a1db",
   "metadata": {},
   "source": [
    "## `libnetwork`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faf185c4",
   "metadata": {},
   "source": [
    "### Drivers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "634f923c",
   "metadata": {},
   "source": [
    "`libnetwork` implements the control plane and management plane functions and drivers implement the data plane."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a11657c2",
   "metadata": {},
   "source": [
    "<img src=\"./images/36.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f032e8ac",
   "metadata": {},
   "source": [
    "- Linux drivers: `bridge`, `overlay`, and `macvlan`.  \n",
    "- Windows drivers: `nat`, `overlay`, `transparent`, and `l2bridge`.\n",
    "- 3rd parties can also write _remote drivers_ or plugins.\n",
    "- The driver is responsible for creating, managing and deletings network resources."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9866634",
   "metadata": {},
   "source": [
    "### Single-host bridge networks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9acdd140",
   "metadata": {},
   "source": [
    "- **Single-host**: only exists on a single Docker host and can only connect containers that are on the same host.\n",
    "- **Bridge**: implementation of an 802.1d bridge (layer 2 switch)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cae333dc",
   "metadata": {},
   "source": [
    "- Linux: created by `bridge` driver.\n",
    "- Windows: created by `nat` driver."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0940adf6",
   "metadata": {},
   "source": [
    "<img src=\"./images/37.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d649dd4",
   "metadata": {},
   "source": [
    "All new containers will be connected to this default network unless `--network` flag is used."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "918607a2",
   "metadata": {},
   "source": [
    "To list all current networks:  \n",
    "`$ docker network ls`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f5f7354",
   "metadata": {},
   "source": [
    "To inspect network driver:  \n",
    "`$ docker network inspect`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa5d408f",
   "metadata": {},
   "source": [
    "The default “bridge” network, on all Linux-based Docker hosts, maps to an underlying _Linux bridge_ in the kernel called **“docker0”**  \n",
    "`$ ip link show`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b91b7148",
   "metadata": {},
   "source": [
    "<img src=\"./images/39.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "33a8edb8",
   "metadata": {},
   "source": [
    "To create a new single-host bridge network called \"localnet\":  \n",
    "`$ docker network create -d bridge localnet`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc268d4b",
   "metadata": {},
   "source": [
    "Check it by:  \n",
    "`$ ip link show`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdad131f",
   "metadata": {},
   "source": [
    "<img src=\"./images/40.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa8f7a31",
   "metadata": {},
   "source": [
    "Create a container and attach it to the new localnet bridge network:  \n",
    "`$ docker container run -d --name c1 --network localnet alpine sleep 1d`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d8229fc",
   "metadata": {},
   "source": [
    "<img src=\"./images/41.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9926663",
   "metadata": {},
   "source": [
    "**Beware:** _The default `bridge` network on Linux does not support name resolution via the Docker DNS service. All other user-defined bridge networks do. The following demo will work because the container is on the user-defined `localnet` network._"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f6b7068",
   "metadata": {},
   "source": [
    "Create a new container called \"c2\":  \n",
    "`$ docker container run -it --name c2 --network localnet alpine sh`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38b17156",
   "metadata": {},
   "source": [
    "`# ping c1`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eec3ab7",
   "metadata": {},
   "source": [
    "Local DNS resolver forwards requests to an internal Docker DNS server that maintains name mapping for containers started with `--name` or `--net-alias` flags."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4532be1e",
   "metadata": {},
   "source": [
    "### Port Mapping"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e6aed04",
   "metadata": {},
   "source": [
    "Containers connected to bridge networks cannot communicate outside it except in the case of _Port Mapping_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da5ffe3d",
   "metadata": {},
   "source": [
    "<img src=\"./images/42.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "837465ee",
   "metadata": {},
   "source": [
    "`$ docker container run -d --name web --network localnet --publish 5000:80 nginx`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e939d60c",
   "metadata": {},
   "source": [
    "To verify port mapping:  \n",
    "`docker port <container-name>`  \n",
    "`$ docker port web`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fbd4e85",
   "metadata": {},
   "source": [
    "### Connecting to existing networks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8e394ca",
   "metadata": {},
   "source": [
    "A common example is a partially containerized app"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c2be34e",
   "metadata": {},
   "source": [
    "The built-in `MACVLAN` driver (`transparent` on Windows) was created with this in mind."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64dd948c",
   "metadata": {},
   "source": [
    "<img src=\"./images/43.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6154129",
   "metadata": {},
   "source": [
    "on the negative side, it requires the host NIC to be in **promiscuous mode**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "860cebee",
   "metadata": {},
   "source": [
    "<img src=\"./images/44.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2721e97",
   "metadata": {},
   "source": [
    "``$ docker network create -d macvlan \\\n",
    "  --subnet=10.0.0.0/24 \\\n",
    "  --ip-range=10.0.0.0/25 \\\n",
    "  --gateway=10.0.0.1 \\\n",
    "  -o parent=eth0.100 \\\n",
    "  macvlan100``"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5323991",
   "metadata": {},
   "source": [
    "<img src=\"./images/45.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "917b8960",
   "metadata": {},
   "source": [
    "Create a container with the macvlan100 network:  \n",
    "`$ docker container ran -d --name mactainer1 --network macvlan100 alpine sleep 1d`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15fab192",
   "metadata": {},
   "source": [
    "<img src=\"./images/46.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d15632a",
   "metadata": {},
   "source": [
    "<img src=\"./images/47.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e9065b",
   "metadata": {},
   "source": [
    "### Service discovery"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c418019c",
   "metadata": {},
   "source": [
    "_Service discovery_ allows all containers and Swarm services to locate each other by name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7112b0e9",
   "metadata": {},
   "source": [
    "<img src=\"./images/48.png\" alt=\"drawing\" width=\"900\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49570afe",
   "metadata": {},
   "source": [
    "_service discovery_ is network-scoped. This means that name resolution only works for containers and Services on the same network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d42d6623",
   "metadata": {},
   "source": [
    "`--dns` flag specifies external DNS server.  \n",
    "`--dns-search` specifies custom search domain suffix  \n",
    "\n",
    "`$ docker container run -it --name c1 \\\n",
    "  --dns=8.8.8.8 \\\n",
    "  --dns-search=nigelpoulton.com \\\n",
    "  alpine sh`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2ef2e9d",
   "metadata": {},
   "source": [
    "### Ingress load balancing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06b60045",
   "metadata": {},
   "source": [
    "Swarm support:  \n",
    "- Ingress mode (default)\n",
    "- Host mode"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "439e3e46",
   "metadata": {},
   "source": [
    "<img src=\"./images/49.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d02ff0a8",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "29e81f0c",
   "metadata": {},
   "source": [
    "## Docker Networking - The Commands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59fdffe0",
   "metadata": {},
   "source": [
    "- `docker network ls`  // Lists all networks on the local Docker host.\n",
    "- `docker network create`  // Creates new Docker networks.\n",
    "- `docker network inspect`  // Provides detailed configuration information about a Docker network.\n",
    "- `docker network prune`  // Deletes all unused networks on a Docker host.\n",
    "- `docker network rm`  // Deletes specific networks on a Docker host."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fedbd07",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "eef69baf",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0e2e83d",
   "metadata": {},
   "source": [
    "# 12: Docker overlay networking"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81c56edb",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a780fac3",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "76847058",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "42424cd1",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e7ba4262",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "58af894d",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "30cc9d7b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "00ed72fb",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27197f25",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a66f2d7f",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "56d8deeb",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7ccfd3fc",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "38fa415f",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "54276f19",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "72e5d34d",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c7ff91e4",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0339bf5",
   "metadata": {},
   "source": [
    "# 13: Volumes and persistent data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7876b9a0",
   "metadata": {},
   "source": [
    "## Volumes and persistent data - The TLDR"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a8bf801",
   "metadata": {},
   "source": [
    "two main categories of data — persistent and non-persistent."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7951c4a",
   "metadata": {},
   "source": [
    "### Volumes and persistent data - The Deep Dive"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b37ca9c",
   "metadata": {},
   "source": [
    "#### Containers and non-persistent data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94b3d536",
   "metadata": {},
   "source": [
    "- Containers are designed to be immutable\n",
    "- many applications require a read-write filesystem in order to simply run – they won’t even run on a read-only filesystem.\n",
    "- Every Docker container is created by adding a thin read-write layer on top of the read-only image it’s based on\n",
    "- The writeable layer is called many names: _local storage_, _ephemeral storage_, and _graphdriver storage_.\n",
    "- It’s typically located on the Docker host in these locations:\n",
    "    - Linux Docker hosts: `/var/lib/docker/<storage-driver>/...`\n",
    "    - Windows Docker hosts: `C:\\ProgramData\\Docker\\windowsfilter\\...`\n",
    "- it gets created when the container is created and it gets deleted when the container is deleted\n",
    "- Managed on Docker host using a storage driver (Ubuntu: `overlay2` or `aufs`. `overlay2` is recommended)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58f99a35",
   "metadata": {},
   "source": [
    "<img src=\"./images/50.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a26dd46",
   "metadata": {},
   "source": [
    "#### Containers and persistent data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "836a5e13",
   "metadata": {},
   "source": [
    "- _Volumes_ are the recommended way to persist data in containers.\n",
    "    - Volumes are independent objects that are not tied to the lifecycle of a container\n",
    "    - Volumes can be mapped to specialized external storage systems\n",
    "    - Volumes enable multiple containers on different Docker hosts to access and share the same data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8438fcd6",
   "metadata": {},
   "source": [
    "1. Create a volume\n",
    "2. Create a container \n",
    "3. Mount the volume into it \n",
    "4. The volume is mounted into a directory in the container’s filesystem\n",
    "5. Anyhing written to that directory is stored in the volume\n",
    "6. If you delete the container, the volume and its data will still exist."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a870302",
   "metadata": {},
   "source": [
    "<img src=\"./images/51.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6ffd7235",
   "metadata": {},
   "source": [
    "### Creating and managing Docker volumes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a52d795",
   "metadata": {},
   "source": [
    "To create a volume using `local` driver:  \n",
    "`$ docker volume create myvol`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "108eb57b",
   "metadata": {},
   "source": [
    "Third-party volume drivers are available as plugins (Cloud, SAN, NAS, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d4a1257",
   "metadata": {},
   "source": [
    "<img src=\"./images/52.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1d90122",
   "metadata": {},
   "source": [
    "To Inspect a volume:  \n",
    "`$ docker volume inspect myvol`"
   ]
  },
  {
   "cell_type": "raw",
   "id": "24e6eea1",
   "metadata": {},
   "source": [
    "[\n",
    "    {\n",
    "        \"CreatedAt\": \"2020-05-02T17:44:34Z\",\n",
    "        \"Driver\": \"local\",\n",
    "        \"Labels\": {},\n",
    "        \"Mountpoint\": \"/var/lib/docker/volumes/myvol/_data\",   /// location in Host's filesystem\n",
    "        \"Name\": \"myvol\",\n",
    "        \"Options\": {},\n",
    "        \"Scope\": \"local\"   /// Only containers in this host will have access to this volume\n",
    "    }\n",
    "]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ce8bbbb",
   "metadata": {},
   "source": [
    "Two ways to delete a Docker volume:  \n",
    "- Remove all volumes not used by any container: `$ docker volume prune`\n",
    "- Choose which volume to remove: `$ docker volume rm <volume-name>`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab841d0",
   "metadata": {},
   "source": [
    "#### Volumes in Dockerfiles"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5dcafa8",
   "metadata": {},
   "source": [
    "- it’s also possible to deploy volumes via Dockerfiles using the VOLUME instruction\n",
    "- The format is `VOLUME <container-mount-point>`\n",
    "- you cannot specify a directory on the host when defining a volume in a Dockerfile"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34a2f7f1",
   "metadata": {},
   "source": [
    "#### Demonstrating volumes with containers and services"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f7d7b35",
   "metadata": {},
   "source": [
    "- `$ docker container run -dit --name voltainer --mount source=bizvol,target=/vol alpine`\n",
    "- `$ docker volume ls`\n",
    "- `$ docker volume rm bizvol`    /// error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d5c612",
   "metadata": {},
   "source": [
    "Write something to volume:  \n",
    "- `$ docker container exec -it voltainer sh`\n",
    "    - `# echo \"I Think Therefore I Am\" > /vol/file1`\n",
    "    - `# cat /vol/file1`\n",
    "    - `# exit`\n",
    "- `$ docker container rm voltainer -f`\n",
    "- `$ docker volume ls`\n",
    "- `$ ls -l /var/lib/docker/volumes/bizvol/_data/`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c99cc08",
   "metadata": {},
   "source": [
    "Create another container and attach it to the previous volume:  \n",
    "- `$ docker run --name hellcat --mount source=bizvol,target=/vol alpine sleep 1d`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47569be8",
   "metadata": {},
   "source": [
    "### Sharing storage across cluster nodes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de4bb0e",
   "metadata": {},
   "source": [
    "<img src=\"./images/53.png\" alt=\"drawing\" width=\"800\" align=\"left\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42fdacca",
   "metadata": {},
   "source": [
    "Docker Hub is the best place to find volume plugins"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f83f666c",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d5336c98",
   "metadata": {},
   "source": [
    "## Volumes and persistent data - The Commands"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2eb743f2",
   "metadata": {},
   "source": [
    "- `docker volume create`  /// create new volumes.\n",
    "- `docker volume ls`  /// list all volumes on the local Docker host.\n",
    "- `docker volume inspect`  /// shows detailed volume information.\n",
    "- `docker volume prune`  /// delete all volumes that are not in use by a container or service replica. Use with caution!\n",
    "- `docker volume rm`   /// deletes specific volumes that are not in use.\n",
    "- `docker plugin install`  /// install new volume plugins from Docker Hub.\n",
    "- `docker plugin ls`  /// lists all plugins installed on a Docker host."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c05cd32",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9e42ef17",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "387fe9f4",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b34a543",
   "metadata": {},
   "source": [
    "# 14: Deploying apps with Docker Stacks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d876932",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ec9b8716",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b3f6364e",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "047566f0",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17b223de",
   "metadata": {},
   "source": [
    "# 15: Security in Docker"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1d4b655",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8ca5e117",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "1fae3ec2",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c314867b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b09da787",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cd429609",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "56ccc1c6",
   "metadata": {},
   "source": [
    "# USED IMAGES"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c99e239c",
   "metadata": {},
   "source": [
    "Microsoft Official Repo  \n",
    "https://hub.docker.com/publishers/microsoftowner"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "744f1b68",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "30ff0d0b",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "9239ef63",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "bf21d63a",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "4520e78c",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "aae6d738",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}