Introduction to Docker

Instructor: Chris Fulton

Learning Objectives

• Understanding what is Docker?
• Images | Containers | Virtual Machines | Containers vs. Virtual Machines
• Practical Use Cases for Web Developers | Containers and Microservices
• Installing Docker
• Docker Desktop | VS Code Plugin | Running Sample Container
• Docker Workflow
• Commonly used Commands
• Docker Hub
• Dockerfile | .dockerignore file
• Containerizing an application
• Docker Compose
• Kubernetes and Swarm
• Deploying + Hosting Containers

What is Docker?

Docker is a set of platform as a service products that uses OS-level virtualization to deliver software in packages called containers.

What is Docker cont.?

Containers vs. Virtual Machines

Containers and virtual machines have similar resource isolation and allocation benefits, but function differently because containers virtualize the operating system instead of hardware. Containers are more portable and efficient.

Containers and Microservices

What does Microservices have to do with container orchestration? Please watch the video below in your own time. The video provides an overview of microservices and how containers are orchestrated.

Docker Use Cases

Simple Environment Configuration
Simple configuration is the primary use case of Docker

App Isolation & Testing
Cautious of erraneous code can be ran in a contained environment. Testing and previewing new applications. Using Docker Hub to pull down preconfigured applications.

Rapid Deployment and Scaling
Easier to deploy an application that runs within a container that contains all of the application processes

Code Pipeline Management
Docker eases the code development and deployment pipeline and offers a consistent environment for the application from dev through production.

Containers vs. Virtual Machines

Please watch the video below in your own time. The video highlights the difference between virtual machines and containers.

What execution environment should your microservices applications use? That is, in what kind of environment should they run?

The best choice for running a microservices application architecture is application containers. Containers encapsulate a lightweight runtime environment for your application, presenting a consistent software environment that can follow the application from the developer's desktop to testing to final production deployment, and you can run containers on physical or virtual machines.

Installing Docker

Install Docker

Activity A - Running Sample Container

								
									# Lets us know the version of docker
									docker --version
									
									# Pulling the hello-world image from Docker Hub and runs the container
									docker run hello-world
									
									# Command to display on the images 
									docker image ls
									
									# Stops container and removes container
									docker container stop hello-world
									
									docker container rm hello-world					
	
								
							

Docker Workflow

Docker CheatSheet and Commands

Docker Cheat Sheet | Docker Command Line Documentation

Docker Hub

DockerHub - the world's easiest way to create, manage, and deliver your teams' container applications.

Activity B -Pulling container from docker hub

Dockerfile

What is a dockerfile - a text file that contains all commands, in order, needed to build a given image

								
# Define from what image we want to build from
FROM node:14.18.1

# Provides metadata regarding the Dockerfile
LABEL version="1.0"
LABEL description="Docker image for class example "
LABEL maintainer = "cifulton@uic.edu"

# Sets the working directory for application in container
WORKDIR /app

# Which files would we like to copy into the construction of the image
COPY . /app

# What commands we would like to run once 
CMD ["node", "app/docker.js"]
					
								
							

Dockerfile Directives

FROM
Defines the image we will use as the basis for our container.

LABEL
Defines the metadata for our Dockerfile, including information about the version, description, and maintainers.

WORKDIR
Sets the working directory for the application. If the working directory does not already exist, it is created by Docker.

COPY
Copy a file or files into the Docker container.

RUN
Specifies a command that should be run by Docker. You typically use this command to install dependencies, debug, and execute commands in the container.

EXPOSE
Tells Docker which ports the container should listen on during runtime.

CMD
Specifies the command that should be executed when the docker container starts.

Creating Dockerfile Steps

1. Create a file called dockerfile
Create a folder and run the touch command to create a Dockerfile. No file extension is needed.

2. Add Instructions in Dockerfile
Dockerfile reference can be found at this link

3. Build Dockerfile to create image
Run the docker build -t newimagename:1.0 to construct image that is now named "newimagename" version "1.0"

4. Run Image to create container
Run the command docker container run --name to run the container.

5. Stop and remove container
Run the command docker container stop [NAME_OF_CONTAINER] and run the command docker container rm [NAME_OF_CONTAINER]

Activity C - Generating Image from Dockerfile

								
								# Step 1 - Defines and invokes function
								dockerSucessOutput();
								function dockerSucessOutput(){
								    console.log("Dockerfile correctly constructed and image and ran program");
								}
								
								# Step 2 - Including directives into Dockerfile
								FROM node:14.18.1
								COPY . /app
								
								CMD ["node", "app/docker.js"]
								
								# Step 3 - Stop container
								docker container stop sample_walkthrough .

								
							

Docker Compose

Compose is a tool for defining and running multi-container Docker applications. With Compose, you use a YAML file to configure your application’s services.

Docker Compose

YAML File Examples below:

								
								version: '1'
								services:
								  front:
								    build: ./front
								    ports:
								      - '3000:3000'
								    depends_on:
								      - back
								  back:
								    build: ./back
								    ports:
								      - '8080:8080'
		
								
							

								
								version: '2'
								
								services:
								   db:
								     image: mysql:5.7
								     volumes:
								       - db_data:/var/lib/mysql
								     restart: always
								     environment:
								       MYSQL_ROOT_PASSWORD: rootpasswordchangeme
								       MYSQL_DATABASE: wordpress
								       MYSQL_USER: usernamechangeme
								       MYSQL_PASSWORD: passwordchangeme
								
								   wordpress:
								     depends_on:
								       - db
								     image: wordpress:latest
								     ports:
								       - "8000:80"
								     restart: always
								     environment:
								       WORDPRESS_DB_HOST: db:3306
								       WORDPRESS_DB_USER: usernamechangeme
								       WORDPRESS_DB_PASSWORD: passwordchangeme
								volumes:
								    db_data:
		
								
							

Getting Started with Docker Compose

1. Build individual images or pull them from a registry.
Make sure each service has it's own Dockerfile that builds an image.

2. Define all services in a docker-compose.yml file.
Once each service has a dockerfile, consider the placement of the .yaml file

3. Run command
Run all of them together using the docker-compose CLI. docker-compose up -d

Kubernetes

Why Kubernetes?

Kubernetes Architecture

Kubernetes runs your workload by placing containers into Pods to run on Nodes

Question 1

How would you best describe Kubernetes?

• A. a subscription platform designed to manually deploy scaling and operating applications within containers
• B. an open-source platform designed for manually deploying, scaling, and operating application containers
• C. a subscription platform designed to automate deploying, scaling, and operating application containers
• D. an open-source platform designed to automate deploying, scaling, and operating application containers

Question 2

What does kubernetes do?

• A. Install Docker and sets up a cluster across multiple VMs
• B. Manages containers and other resources defined in a YAML file
• C. Build container images across a cluster of machines

Question 3

How does kubernetes group containers together?

• A. In a cluster, where all containers are deployed on the same VM
• B. In a service, where all containers share the same networking namespace
• C. In a pod, where all containers share the same network and compute environment

Question 4

Which feature in kubernetes assigns pods to a node at runtime?

• A. scalability and availability
• B. service discovery
• C. container scheduling
• D. flexibility and modularization

Good Video - Kubernetes in 5min

Documentation on getting started with Kubernetes using docker desktop. Link found here.

Deploying Containers

Deploying Container

There are many deployment methods in which we can deploy containers or kubrnetes.

• Free cloud services to host container - Deploy using Heroku or Digital Ocean. Directions for deploying to Heroku can be found here. Directions to deploying to Digital Ocean can be found here.


• Hosting Kubernetes cluster - Example tutorial of hosting kubernetes cluster on Digital Ocean.

GitHub Actions Deployment of container

								
		# Your workflow name.
name: Deploy to heroku.

# Run workflow on every push to master branch.
on:
  push:
    branches: [main]

# Your workflows jobs.
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      # Check-out your repository.
      - name: Checkout
        uses: actions/checkout@v2


### ⬇ IMPORTANT PART ⬇ ###

      - name: Build, Push and Release a Docker container to Heroku. # Your custom step name
        uses: gonuit/heroku-docker-deploy@v1.3.2 # GitHub action name (leave it as it is).
        with:
          # Below you must provide variables for your Heroku app.

          # The email address associated with your Heroku account.
          # If you don't want to use repository secrets (which is recommended) you can do:
          # email: my.email@example.com
          email: ${{ secrets.HEROKU_EMAIL }}
          
          # Heroku API key associated with provided user's email.
          # Api Key is available under your Heroku account settings.
          heroku_api_key: ${{ secrets.HEROKU_API_KEY }}
          
          # Name of the heroku application to which the build is to be sent.
          heroku_app_name: ${{ secrets.HEROKU_APP_NAME }}

          # (Optional, default: "./")
          # Dockerfile directory.
          # For example, if you have a Dockerfile in the root of your project, leave it as follows:
          dockerfile_directory: ./

          # (Optional, default: "Dockerfile")
          # Dockerfile name.
          dockerfile_name: Dockerfile

          # (Optional, default: "")
          # Additional options of docker build command.
          docker_options: "--no-cache"

          # (Optional, default: "web")
          # Select the process type for which you want the docker container to be uploaded.
          # By default, this argument is set to "web".
          # For more information look at https://devcenter.heroku.com/articles/process-model
          process_type: web
          
   
          
### ⬆ IMPORTANT PART ⬆ ###

								
							

References

• https://github.com/docker/labs/blob/master/beginner/chapters/webapps.md
• https://dzone.com/articles/a-developers-guide-to-docker-docker-compose
• https://data-flair.training/blogs/docker-use-cases/
• https://www.docker.com/resources/what-container
• https://gravitational.com/blog/microservices-containers-kubernetes/
• https://github.com/wsargent/docker-cheat-sheet#dockerfile