Docker für Unix/Linux/Ubuntu

1: Installiere Docker und teste die Version.

https://docs.docker.com/install/

sudo apt-get remove docker docker-engine docker.io

docker --version

2: Installiere Docker-Compose.

Die neuste Version installieren, und Zugriffsrechte in /usr/local/bin ändern.

https://github.com/docker/compose/releases

#!/bin/bash

# get latest docker compose released tag
COMPOSE_VERSION=$(curl -s https://api.github.com/repos/docker/compose/releases/latest | grep 'tag_name' | cut -d\" -f4)

# Install docker-compose
sh -c "curl -L https://github.com/docker/compose/releases/download/${COMPOSE_VERSION}/docker-compose-`uname -s`-`uname -m` > /usr/local/bin/docker-compose"
chmod +x /usr/local/bin/docker-compose
sh -c "curl -L https://raw.githubusercontent.com/docker/compose/${COMPOSE_VERSION}/contrib/completion/bash/docker-compose > /etc/bash_completion.d/docker-compose"

# Output compose version
docker-compose -v

exit 0

3: Nutzung.

Um ein Image zu erstellen, erstelle einen Ordner und erzeuge eine Datei mit dem Namen Dockerfile dort. Platziere die jar Datei auch in diesem Ordner. Die Dockerfile Datei sollte ungefähr so aussehen:

# Start with a base image containing Java runtime
FROM openjdk:8-jdk-alpine

# Add Maintainer Info
LABEL maintainer="test use 1"

# Add a volume pointing to /tmp
VOLUME /tmp

# Make port 8080 available to the world outside this container
EXPOSE 8080

# The application's jar file
ARG JAR_FILE=Notlage-1.jar

# Add the application's jar to the container
ADD ${JAR_FILE} notlage-app.jar

# Run the jar file 
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/notlage-app.jar"]

Führe folgenden Befehl in Docker aus, um das Image zu erzeugen:

(Terminal muss im gleichen Ordner sein wie die Dockerfile.)

docker build -t my_image_name .
docker build --no-cache -t u12_core .

Liste alle Images auf:

docker image ls

Liste alle Container auf. (running, all)

docker container ls
docker container ls --all

Save and load image: (to transfer it to other systems as a file)

docker save -o <path for generated tar file> <image name>
docker save image > /home/save.tar
	
docker load -i <path to image tar file>

Weitere wichtige Befehle:

Betrachte alle Docker internen Netzwerke und inspeziere eines. Man erhält eine Liste aller laufenden Container in einem Netzwerk, mit deren echten Namen. Dies ist wichtig, wenn man einen Container mit seinem Hostnamen ansprechen will. (z.B. bei Kafka Bootstrap Server)

https://docs.docker.com/engine/reference/commandline/network_ls/

docker network ls
docker network inspect <network name>

4: Docker-Compose

Mit up wird die docker-compose.yml Datei ausgeführt.

Mit down wird diese wieder beendet.

(Terminal muss im gleichen Ordner sein wie die docker-compose.yml Datei)

docker-compose up
docker-compose down

docker-compose ps

Die docker-compose.yml Datei sollte so aussehen:

version: "3"

services:
 ms-notlage:
  image: ms-notlage
  ports: 
   - "8080:8080"
  networks:
   - kafka_backend

networks:
 kafka_backend:
  external: true

Achte auf korrektes Einrücken.

services gibt die Liste aller zu erzeugender Container an. image: name des nu verwendeten images. port: Port forwarding outside the Docker network. networks: Das Netzwerk in dem sich der Container befindne soll. Wenn dieser eintrag ausgelassen wird, dann wird ein neues Netzwerk nur für diesen Container erzeugt.

external: true bedeutet, dass dieses Netz schon existiert. Besodenrs in Bezug zu Kafka und Microservices die miteinader kommunizieren ist es wichtig, im gleichen Netz zu sein, bzw. die korrekte Adresse zu kennen. Kommunikation innerhalb eines Netzes und außerhalb ist unterschiedlich.

Weiteres:

Listet alle Container auf.

docker-compose ps

Entferne ein Image oder einen Container.

docker rmi <image_name>
docker rm <container name>

docker system prune
docker container prune
docker image prune