kwiecien/docker-katacoda

https://www.katacoda.com/courses/docker/

docker-katacoda

https://www.katacoda.com/courses/docker/

• Deploying Your First Docker Container
• Deploy Static HTML Website as Container
• Building Container Images
• Dockerizing Node.js applications
• Optimising Dockerfile with OnBuild
• Ignoring Files
• Data Containers

Table of contents generated with markdown-toc

Deploying Your First Docker Container

Step 1 - Running A Container

docker search redis
docker run -d redis

Step 2 - Finding Running Containers

docker ps
docker inspect agitated_mendeleev
docker logs agitated_mendeleev

Step 3 - Accessing Redis

docker run -d --name redisHostPort -p 6379:6379 redis:latest

Step 4 - Accessing Redis

docker run -d --name redisDynamic -p 6379 redis:latest
docker port redisDynamic 6379
docker ps

Step 5 - Persisting Data

docker run -d --name redisMapped -v /opt/docker/data/redis:/data redis
docker run -d --name redisMappedPwd -v "$PWD/data":/data redis

Step 6 - Running A Container In The Foreground

docker run ubuntu ps
docker run -it ubuntu bash

Deploy Static HTML Website as Container

Step 1 - Create Dockerfile

FROM nginx:alpine
COPY . /usr/share/nginx/html

Step 2 - Build Docker Image

docker build -t webserver-image:v1 .
docker images

Step 3 - Run

docker run -d -p 80:80 webserver-image:v1
curl docker

Building Container Images

Step 1 - Base Images

FROM nginx:1.11-alpine

Step 2 - Running Commands

COPY index.html /usr/share/nginx/html/index.html

Step 3 - Exposing Ports

EXPOSE 80

Step 4 - Default Commands

CMD ["nginx", "-g", "daemon off;"]

Step 5 - Building Containers

docker build -t my-nginx-image:latest .
docker images

Step 6 - Launching New Image

docker run -d -p 80:80 my-nginx-image:latest
curl -i http://docker
docker ps

Dockerizing Node.js applications

Step 1 - Base Image

FROM node:10-alpine
RUN mkdir -p /src/app
WORKDIR /src/app

Step 2 - NPM Install

COPY package.json /src/app/package.json
RUN npm install

Step 3 - Configuring Application

COPY . /src/app
EXPOSE 3000
CMD ["npm", "start"]

Step 4 - Building & Launching Container

docker build -t my-nodejs-app .
docker run -d --name my-running-app -p 3000:3000 my-nodejs-app
curl http://docker:3000

Step 5 - Environment Variables

docker run -d --name my-production-running-app -e NODE_ENV=production -p 3000:3000 my-nodejs-app

Optimising Dockerfile with OnBuild

Step 1 - OnBuild

FROM node:7
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
ONBUILD COPY package.json /usr/src/app/
ONBUILD RUN npm install
ONBUILD COPY . /usr/src/app
CMD [ "npm", "start" ]

Step 2 - Application Dockerfile

FROM node:7-onbuild
EXPOSE 3000

Step 3 - Building & Launching Container

docker build -t my-nodejs-app .

docker run -d --name my-running-app -p 3000:3000 my-nodejs-app

curl http://docker:3000

Ignoring Files

Step 1 - Docker Ignore

cat Dockerfile
docker build -t password .
docker run password ls /app

echo passwords.txt >> .dockerignore

docker build -t nopassword .
docker run nopassword ls /app

Step 2 - Docker Build Context

docker build -t large-file-context .

Step 3 - Optimised Build

echo big-temp-file.img >> .dockerignore
docker build -t no-large-file-context .

Data Containers

Step 1 - Create Container

docker create -v /config --name dataContainer busybox

Step 2 - Copy Files

docker cp config.conf dataContainer:/config/

Step 3 - Mount Volumes From

docker run --volumes-from dataContainer ubuntu ls /config

Step 4 - Export / Import Containers

docker export dataContainer > dataContainer.tar
ls
docker import dataContainer.tar

Communicating Between Containers

Step 1 - Start Redis

docker run -d --name redis-server redis

Step 2 - Create Link

docker run --link redis-server:redis alpine env
docker run --link redis-server:redis alpine cat /etc/hosts
docker run --link redis-server:redis alpine ping -c 1 redis

Step 3 - Connect To App

docker run -d -p 3000:3000 --link redis-server:redis katacoda/redis-node-docker-example
curl docker:3000

Step 4 - Connect to Redis CLI

docker run -it --link redis-server:redis redis redis-cli -h redis
KEYS *
QUIT

Docker Networks

Step 1 - Create Network

docker network create backend-network
docker run -d --name=redis --net=backend-network redis

Step 2 - Network Communication

docker run --net=backend-network alpine env
docker run --net=backend-network alpine cat /etc/hosts
docker run --net=backend-network alpine cat /etc/resolv.conf
docker run --net=backend-network alpine ping -c1 redis

Step 3 - Connect Two Containers

docker network create frontend-network
docker network connect frontend-network redis
docker run -d -p 3000:3000 --net=frontend-network katacoda/redis-node-docker-example
curl docker:3000

Step 4 - Create Aliases

docker network create frontend-network2
docker network connect --alias db frontend-network2 redis
docker run --net=frontend-network2 alpine ping -c1 db

Step 5 - Disconnect Containers

docker network ls
docker network inspect frontend-network
docker network disconnect frontend-network redis

Persisting Data Using Volumes

Step 1 - Data Volumes

docker run -v /docker/redis-data:/data --name r1 -d redis redis-server --appendonly yes
cat data | docker exec -i r1 redis-cli --pipe
ls /docker/redis-data
docker run -v /docker/redis-data:/backup ubuntu ls /backup

Step 2 - Shared Volumes

docker run --volumes-from r1 -it ubuntu ls /data

Step 3 - Read-only Volumes

[root@host01 ~]# docker run -v /docker/redis-data:/data:ro -it ubuntu rm -rf /data
rm: cannot remove '/data/appendonly.aof': Read-only file system