Docker

https://www.linux.com/blog/learn/chapter/Containers-Devs/2017/6/basic-commands-performing-docker-container-operations

Image runterladen

docker pull

Alle Images im lokalen repository zeigen

docker images

Container aus heruntergeladenem Image erzeugen

docker create

Details siehe https://docs.docker.com/engine/reference/commandline/create/

docker create erzeugt den Container und startet ihn nicht, docker run macht beides.

Alle laufenden und gestoppten Container zeigen:

docker ps -a

Filtern auf laufende Container

docker ps -a -f status=running

Laufende und gestoppte, aber nur die container id ausgeben

docker ps -aq

Container entfernen, die nicht laufen

docker rm `docker ps -aq -f status=exited`

Container starten/stoppen

docker start [ID]

docker stop [ID]

Container betreten

docker exec -t -i container_ID /bin/bash

Bis Docker 1.12 gibt es diesen Bug https://github.com/moby/moby/issues/9299
Lauf http://nortpoint.io/2016/04/04/editing-a-file-in-a-running-docker-container/ hilft dagegen:

export TERM=xterm

Alternativ: stdin/out an den Container hängen:

''docker attach [OPTIONS] CONTAINER''

Achtung: wieder raus mit CTRL-p CTRL-q. Details siehe https://docs.docker.com/engine/reference/commandline/attach/

Docker Netzwerk

Standardmässig werden drei Netze angelegt:

''locutus:/home/thommie # docker network ls
NETWORK ID          NAME                DRIVER              SCOPE
fcb988056c63        bridge              bridge              local
1e815c6a856e        host                host                local
a45f22d51759        none                null                local ''

Container werden an die bridge (entspricht docker0 auf dem Host) gebunden, solange nicht beim docker create ein anderes Netzwerk gewählt wurde (docker create –network=<NETWORK>)

Mit docker network inspect sieht man den Zustand des Docker Netzwerks

locutus:/home/thommie # docker network inspect bridge
[
    {
        "Name": "bridge",
        "Id": "fcb988056c63e52c352807398cac63f2650980708df494a8e6e11b6bf4c25b06",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": null,
            "Config": [
                {
                    "Subnet": "172.17.0.0/16",
                    "Gateway": "172.17.0.1"
                }
            ]
        },
        "Internal": false,
        "Containers": {
            "6ef4beb1a63a244d1e3a4c9cdd17fb4d7aa9ecf43ebc51149d242ee56c39e564": {
                "Name": "docker-kodi.service",
                "EndpointID": "4e742b892137c61ef27a2b5dc188e15a652502f10ef4012646e1fa20762b517d",
                "MacAddress": "02:42:ac:11:00:02",
                "IPv4Address": "172.17.0.2/16",
                "IPv6Address": ""
            }
        },
        "Options": {
            "com.docker.network.bridge.default_bridge": "true",
            "com.docker.network.bridge.enable_icc": "true",
            "com.docker.network.bridge.enable_ip_masquerade": "true",
            "com.docker.network.bridge.host_binding_ipv4": "0.0.0.0",
            "com.docker.network.bridge.name": "docker0",
            "com.docker.network.driver.mtu": "1500"
        },
        "Labels": {}
    }
]

Auf 127.0.0.11 läuft ein Docker-interner DS Server. Siehe auch https://docs.docker.com/engine/userguide/networking/configure-dns/

docker network create erzeugt ein eigenes Netzwerk:

docker network create –subnet 192.168.82.0/24 –driver bridge bridge2

locutus:/home/thommie # docker network inspect bridge2
[
    {
        "Name": "bridge2",
        "Id": "9c353bcf0c2c6ccee0b821e1ff4d1740a074bdea94e93959c522d46a4e6fde8e",
        "Scope": "local",
        "Driver": "bridge",
        "EnableIPv6": false,
        "IPAM": {
            "Driver": "default",
            "Options": {},
            "Config": [
                {
                    "Subnet": "192.168.82.0/24"
                }
            ]
        },
        "Internal": false,
        "Containers": {},
        "Options": {},
        "Labels": {}
    }
]

Mit

''docker attach container1''

sieht man das Netzwerk von innen

Docker volumes

Kodi headless

Image vom Docker Hub holen

''docker pull linuxserver/kodi-headless''

Container aus Image erzeugen

  • p 8080 - webui port
  • -p 9777/udp - esall interface port
  • -v /config/.kodi - path for kodi configuration files
  • -e PGID GroupID docker group
  • -e PUID UserID docker user
  • -e TZ - for timezone information eg Europe/London, etc
  • –restart=„always“ - Restart policy
docker create –-name=kodi-headless -v /var/lib/kodi/.config/.kodi --restart=always -v /var/lib/kodi/.kodi -e PGID=474 -e PUID=1001 -e TZ=Europe/Berlin -p 8080:8080 -p 9777:9777/udp linuxserver/kodi-headless

Kubernetes

  • Master = koordiniert den Cluster über die Kubernetes API - auf dem Master laufen keine Pods
  • Node = Maschine, auf der Cluster (Pod) laufen (kann eine oder mehrere phys. Maschine oder VMs sein)
  • Pod = einer oder mehrere Container, die gemeinsam Ressourcen nutzen (z.B. gemeinsamer Speicherplatz, gemeinsame IP Adresse, Informationen, wie der Container zu betreiben ist). Pod = Container + gemeinsame Ressourcen (Speicher, RAM, CPU, Netzwerk usw.)
  • Service: Funktion, die von einem oder mehreren Pods bereitgestellt wird

Minikube is a tool that makes it easy to run Kubernetes locally. Minikube runs a single-node Kubernetes cluster inside a VM on your laptop for users looking to try out Kubernetes or develop with it day-to-day.

https://github.com/kubernetes/minikube

curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube
mv minikube /usr/local/bin/

Linux CI Installation Which Supports Running in a VM (example w/ kubectl installation)

curl -Lo minikube https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
chmod +x minikube

dann

curl -Lo kubectl https://storage.googleapis.com/kubernetes-release/release/

$( curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt
)  /bin/linux/amd64/kubectl

chmod +x kubectl

und

export MINIKUBE_WANTUPDATENOTIFICATION=false

export MINIKUBE_WANTREPORTERRORPROMPT=false

export MINIKUBE_HOME=
$HOME
export CHANGE_MINIKUBE_NONE_USER=true
mkdir
$HOME /.kube
||
true touch
$HOME /.kube/config

export KUBECONFIG=
$HOME /.kube/config
sudo -E ./minikube start --vm-driver=none

# this for loop waits until kubectl can access the api server that minikube has created
for
i
in {1..150}

# timeout for 5 minutes
do ./kubectl get po
&> /dev/null

if [
$?
-ne 1 ]
;
then
break
fi sleep 2

done

Minikube mit node.js hello world applikation:

https://kubernetes.io/docs/tutorials/stateless-application/hello-minikube/

  • docker.txt
  • Zuletzt geändert: vor 19 Monaten
  • von thommie