Docker

Docker is an open platform for developers and sysadmins to build, ship, and run distributed applications.

http://www.zdnet.com/article/what-is-docker-and-why-is-it-so-darn-popular/

Developers can use Docker to pack, ship, and run any application as a lightweight, portable, self sufficient LXC container that can run virtually anywhere.

In a nutshell, here's what Docker can do for you: It can get more applications running on the same hardware than other technologies; it makes it easy for developers to quickly create, ready-to-run containered applications; and it makes managing and deploying applications much easier.

http://en.wikipedia.org/wiki/LXC

LXC (Linux Containers) is an operating system–level virtualization method for running multiple isolated Linux systems (containers) on a single control host.

LXC provides operating system-level virtualization through a virtual environment that has its own process and network space, instead of creating a full-fledged virtual machine.

Tutorial

https://www.docker.com/tryit

https://hub.docker.com/

https://docs.docker.com/installation

https://docs.docker.com/articles/basics/

Windows install

https://docs.docker.com/installation/windows/

The Docker Engine uses Linux-specific kernel features, so to run it on Windows we need to use a lightweight virtual machine (vm).

docker run hello-world

Docker SSH container Ubuntu

https://docs.docker.com/examples/running_ssh_service/

In bootDocker create ~/ssh/Dockerfile :

# sshd
#
# VERSION               0.0.2

FROM ubuntu:14.04
MAINTAINER Sven Dowideit <SvenDowideit@docker.com>

RUN apt-get update && apt-get install -y openssh-server
RUN mkdir /var/run/sshd
RUN echo 'root:screencast' | chpasswd
RUN sed -i 's/PermitRootLogin without-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# SSH login fix. Otherwise user is kicked off after login
RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd

ENV NOTVISIBLE "in users profile"
RUN echo "export VISIBLE=now" >> /etc/profile

EXPOSE 22
CMD ["/usr/sbin/sshd", "-D"]

docker build -t eg_sshd .
docker run -d -P --name test_sshd eg_sshd
docker ps -l
ssh root@127.0.0.1 -p49153 # password screencast
sudo docker stop test_sshd # stop container test_sshd

Install jdk8 in trusty

apt-get install software-properties-common
add-apt-repository ppa:openjdk-r/ppa -y
apt-get update
apt-get install openjdk-8-jdk

Dockerfile

FROM ubuntu:14.04

RUN apt-get update && \
    apt-get install -y traceroute openssh-server software-properties-common mongodb rabbitmq-server  && \
    add-apt-repository ppa:openjdk-r/ppa -y && \
    apt-get update && \
    apt-get install -y openjdk-8-jdk

RUN mkdir /var/run/sshd
RUN echo 'root:12345678' | chpasswd
RUN sed -i 's/PermitRootLogin without-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# SSH login fix. Otherwise user is kicked off after login
RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd

ENV NOTVISIBLE "in users profile"
RUN echo "export VISIBLE=now" >> /etc/profile

EXPOSE 22 8080 8081 8082 5672 15672 27017 80
CMD ["/usr/sbin/sshd", "-D"]

Install Docker CE slack 64 14.2

https://slackbuilds.org/repository/14.2/system/docker/

Install go lang

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/development/google-go-lang.tar.gz
tar xvzf google-go-lang.tar.gz
cd google-go-lang
wget https://storage.googleapis.com/golang/go1.10.1.src.tar.gz
change slackbuild to use 1.10.1
./google-go-lang.SlackBuild
installpkg /tmp/google-go-lang-1.9.5-x86_64-1_SBo.tgz
go --version 

In ~/.bashrc 
export GOPATH="$HOME:/usr/share/gocode"
go help buildmode
go get golang.org/x/tools/cmd/godoc

remove support to gcc-go !

/usr/lib64/go1.10.1/go/bin/
/usr/lib64/go1.10.1/go/bin/go version
# in ~/.bashrc
export PATH="$PATH:/usr/lib64/go1.10.1/go/bin/"

Install docker-proxy

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/system/docker-proxy.tar.gz
tar xvzf docker-proxy.tar.gz
cd docker-proxy
wget https://github.com/docker/libnetwork/archive/1b91bc9/libnetwork-1b91bc94094ecfdae41daa465cc0c8df37dfb3dd.tar.gz
./docker-proxy.SlackBuild 
installpkg /tmp/docker-proxy-20180314_1b91bc9-x86_64-1_SBo.tgz

Install tini

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/system/tini.tar.gz
tar xvzf tini.tar.gz 
cd tini
wget https://github.com/krallin/tini/archive/949e6fa/tini-949e6facb77383876aeff8a6944dde66b3089574.tar.gz
./tini.SlackBuild 
installpkg /tmp/tini-0.13.0_949e6fa-x86_64-1_SBo.tgz

Install libseccomp

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/libraries/libseccomp.tar.gz
tar xvzf libseccomp.tar.gz
cd libseccomp
wget https://github.com/seccomp/libseccomp/archive/v2.3.3/libseccomp-2.3.3.tar.gz
./libseccomp.SlackBuild 
installpkg /tmp/libseccomp-2.3.3-x86_64-1_SBo.tgz

Install runc

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/system/runc.tar.gz
tar xvzf runc.tar.gz 
cd runc
wget https://github.com/opencontainers/runc/archive/v1.0.0-rc5/runc-1.0.0-rc5.tar.gz
./runc.SlackBuild 
installpkg /tmp/runc-1.0.0_rc5-x86_64-1_SBo.tgz

Install containerd

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/system/containerd.tar.gz
tar xvzf containerd.tar.gz
cd containerd
wget https://github.com/containerd/containerd/archive/v1.0.2/containerd-1.0.2.tar.gz
./containerd.SlackBuild 
installpkg /tmp/containerd-1.0.2-x86_64-1_SBo.tgz

Install docker

cd /tmp
wget https://slackbuilds.org/slackbuilds/14.2/system/docker.tar.gz
tar xvzf docker.tar.gz
cd docker 
wget https://github.com/docker/docker-ce/archive/v18.03.0-ce/docker-ce-18.03.0-ce.tar.gz
./docker.SlackBuild
installpkg /tmp/docker-18.03.0-x86_64-1_SBo.tgz

Added option --userland-proxy=false in  /etc/rc.d/rc.docker variable 
DOCKER_OPTS="--userland-proxy=false"

cd /etc/rc.d
sh rc.docker status
sh rc.docker start

Docker image with SSH Ubuntu Xenial 16.04

Adapted from https://docs.docker.com/engine/examples/running_ssh_service/

Dockerfile:

# https://docs.docker.com/engine/examples/running_ssh_service/
FROM ubuntu:16.04

RUN apt-get update && apt-get install -y openssh-server
RUN mkdir /var/run/sshd
RUN echo 'root:screencast' | chpasswd
RUN sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# SSH login fix. Otherwise user is kicked off after login
RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd

ENV NOTVISIBLE "in users profile"
RUN echo "export VISIBLE=now" >> /etc/profile
RUN useradd userx
RUN echo 'userx:userx' | chpasswd

EXPOSE 22
CMD ["/usr/sbin/sshd", "-D"]

Steps:

docker build -t docker_test . 
docker run -d -P --name test_container1 docker_test 
docker ps -a
ssh root@127.0.0.1 -p32771
useradd userx
echo 'userx:userx' | chpasswd
ssh userx@127.0.0.1 -p32771
docker container stop test_container1
docker container rm test_container1
docker image rm docker_test

Install Docker in Ubuntu Xenial (16.04.4) vagrant box

   1 mkdir tmp
   2 cd tmp
   3 vagrant init ubuntu/xenial64
   4 vagrant up
   5 vagrant ssh
   6 # inside the box with user vagrant
   7 sudo bash
   8 apt-get update
   9 apt-get install apt-transport-https  ca-certificates curl  software-properties-common
  10 curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
  11 apt-key fingerprint 0EBFCD88
  12 add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
  13 apt-get update
  14 apt-get install docker-ce
  15 docker run hello-world
  16 usermod -aG docker
  17 exit
  18 exit
  19 #login again with vagrant ssh
  20 # as user vagrant 
  21 docker run hello-world
  22 # install java and maven 
  23 apt-get install openjdk-8-jdk
  24 apt-get install maven

Commands

   1 docker ps -a # showall containers
   2 docker system prune -a # clean system 
   3 docker ps -a | awk '//{print $1}' | grep  -v "CONTAINER" | xargs -i sh -c 'docker stop {};docker rm {}'  # clear all containers
   4 docker build -t acme_app . # build image from docker file
   5 docker run -P -p 8080:80 -d acme_app # run dettached container from image acme_app mapping port 8080 to port exposed 80
   6

Docker DNS server

https://docs.docker.com/v17.09/engine/userguide/networking/configure-dns/

As of Docker 1.10, the docker daemon implements an embedded DNS server which provides built-in service discovery for any container created with a valid name or net-alias or aliased by link.

So you should not assume the way the files such as /etc/hosts, /etc/resolv.conf are managed inside the containers and leave the files alone and use the following Docker options instead.

Note: The DNS server is always at 127.0.0.11.

Docker container based on GCC image

   1 docker run -it gcc /bin/bash
   2 docer ps -a
   3 docker exec -it <container> /bin/bash
   4 # inside container
   5 cat /etc/os-release
   6 apt-get update

Docker playground - cherrypy

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

Dockerfile

   1 # docker build -t image_cherrypy . # build image from Dockerfile
   2 # docker run -P -p 8080:80 -d image_cherrypy
   3 # touch cherrypytest.wsgi
   4 # links http://localhost/add/3/4
   5 # curl -X POST -d "{\"name\":\"jkl\"}" http://localhost/hellojson --header "Content-Type:application/json"
   6 FROM ubuntu:16.04
   7 RUN apt-get update && apt-get install -y python libapache2-mod-wsgi apache2 vim links net-tools nano curl wget
   8 RUN wget https://pypi.python.org/packages/source/C/CherryPy/CherryPy-3.2.4.tar.gz
   9 RUN cp CherryPy-3.2.4.tar.gz /tmp
  10 RUN cd /tmp && tar xvzf CherryPy-3.2.4.tar.gz
  11 RUN cd /tmp/CherryPy-3.2.4 && python setup.py build && python setup.py install
  12 RUN mkdir -p /var/www/htdocs/cherrypytest/static
  13 # copy cherrypytest.wsgi from where the Dockerfile is
  14 COPY cherrypytest.wsgi /var/www/htdocs/cherrypytest/cherrypytest.wsgi
  15 RUN echo "Static Test" > /var/www/htdocs/cherrypytest/static/a.txt
  16 RUN echo "<VirtualHost *:80>\nServerName localhost\nDocumentRoot \"/var/www/htdocs/cherrypytest\"\nWSGIScriptAlias / /var/www/htdocs/cherrypytest/cherrypytest.wsgi\n<Directory \"/var/www/htdocs/cherrypytest\">\nRequire all granted\n</Directory>\n</VirtualHost>" > /etc/apache2/sites-available/000-default.conf
  17 RUN echo "#!/bin/sh\n service apache2 start \n tail -f /var/log/apache2/error.log" > /start.sh
  18 EXPOSE 80
  19 CMD ["sh","/start.sh"]

cherrypytest.wsgi

   1 import sys
   2 sys.stdout = sys.stderr
   3 import cherrypy
   4 
   5 cherrypy.config.update({'environment': 'embedded'})
   6 
   7 class HelloWorld(object):
   8     @cherrypy.expose
   9     def index(self):
  10         return "Hello World CherryPy!!!!"
  11 
  12     @cherrypy.expose
  13     def add(self,param1,param2):
  14        return str( int(param1)+int(param2) )
  15 
  16     @cherrypy.expose
  17     @cherrypy.tools.json_in()
  18     @cherrypy.tools.json_out()
  19     def hellojson(self): 
  20         #  curl -X POST -d "{\"name\":\"jkl\"}" http://localhostcherrypytest/hellojson --header "Content-Type:application/json"
  21         inj = cherrypy.request.json
  22         return {"message": "hello world " + inj['name'] }
  23 
  24 hello = HelloWorld()    
  25 #static dir
  26 confx={'/static': {'tools.staticdir.on':True ,
  27                   'tools.staticdir.dir':'/var/www/htdocs/cherrypytest/static'
  28                   }}
  29 application = cherrypy.Application(hello, script_name=None, config=confx)

Docker - openjdk8 - hello

Main.java

   1 //Main.java
   2 public class Main{
   3     public static void main(String args[]){
   4         System.out.println("Hello docker!");
   5     }
   6 }

Dockerfile

   1 FROM openjdk:8-alpine
   2 RUN mkdir -p /usr/src/hello_docker
   3 COPY . /usr/src/hello_docker
   4 WORKDIR /usr/src/hello_docker
   5 RUN javac Main.java
   6 CMD ["java", "Main"]

Execute

   1 # build image hello-docker-image using Dockerfile
   2 docker build -t hello-docker-image . 
   3 # run the container based on the image
   4 docker run -it --rm --name hello-docker hello-docker-image

Docker - openjdk 8 - hello - maven

mkdir -p src/main/java/com/example/artifactX

pom.xml

   1 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   2         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
   3         http://maven.apache.org/maven-v4_0_0.xsd">
   4   <modelVersion>4.0.0</modelVersion>
   5   <groupId>com.example</groupId>
   6   <artifactId>artifactX</artifactId>
   7   <packaging>jar</packaging>
   8   <version>0.0.1</version>
   9   <name>artifactX</name>
  10   <url>http://maven.apache.org</url>
  11   <build>
  12     <plugins>
  13       <plugin>
  14         <artifactId>maven-assembly-plugin</artifactId>
  15         <version>2.4</version>
  16         <configuration>
  17           <descriptorRefs>
  18             <descriptorRef>jar-with-dependencies</descriptorRef>
  19           </descriptorRefs>
  20           <archive>
  21             <manifest>
  22               <mainClass>com.example.artifactX.Main</mainClass>
  23             </manifest>
  24           </archive>
  25         </configuration>
  26         <executions>
  27           <execution>
  28             <id>make-assembly</id> 
  29             <phase>package</phase> 
  30             <goals>
  31               <goal>single</goal>
  32             </goals>
  33           </execution>
  34         </executions>
  35       </plugin>
  36     </plugins>
  37   </build>
  38   <dependencies>
  39   </dependencies>
  40 </project>

src/main/java/com/example/artifactX/Main.java

   1 package com.example.artifactX;
   2 //Main.java
   3 public class Main{
   4     public static void main(String args[]){
   5         System.out.println("Hello docker!");
   6     }
   7 }

Dockerfile

   1 FROM openjdk:8-alpine
   2 RUN apk add maven
   3 RUN mkdir -p /usr/src/hello_maven_docker 
   4 COPY . /usr/src/hello_maven_docker 
   5 WORKDIR /usr/src/hello_maven_docker 
   6 RUN mvn clean install
   7 CMD ["java", "-jar" , "target/artifactX-0.0.1-jar-with-dependencies.jar"]

Execute

   1 docker build -t hello-maven-docker-image .
   2 docker run -it --rm --name hello-maven-docker hello-maven-docker-image