# Aby docker sie nie wylaczal po wyjsciu z niego. Uzyjemy parametru “unless stop” – oznacza to, ze docker bedzie chodzil dopoki nie wydamy polecenia “docker stop …”
$ docker run -it –restart unless-stopped –name ciagle_na_chodzie ubuntu bash

# Kontener po zakonczeniu dzialania zostanie usuniety:
$ docker run –rm centos echo “Jestem przez chwile”

# Usuwanie dockera:
$ docker rm nazwa/id

# Zatrymanie wszystkich kontenerów:
$ docker stop $(docker ps -aq)

# Usuwanie wszystkich wyłaczonych kontenerów:
$ docker rm $(docker ps -aq)

# Wyswietla ostatni zamkniety kontener:

$ docker ps -ll

# Zapisywanie nowego/commit image kontenera po wprowadzeniu w nim zmian:
$ docker commit id_contenera

# Commitowanie kontenera z swoja nazwa np bryn1ek/sryniek:
$ docker commit -m=”Nazwa” nazwa_utworzonego_kontenera moje_repo_dockerhub

# Po commicie otagowywujemy nowy kontener:
$ docker tag id_commitu moja_nazwa

# Co w dane image jest zawarte np: info z ustawieniami w dockerze
$ docker inspect nazwa_dockera

# Zmiana nazwy image jezeli np nam sie nie podoba. Zamiast latest moze byc wersja np 18.04
$ docker tag nazwa_image:latest nowa_nazwa:latest

# Wysyłamy kontener do naszego docker hub
# Najpier musimy zmienic nazwe na nazwe naszego repa na docker hub czylu w tyn przypadku bryn1u/bryniek:

$ docker tag nazwa_kontenera:tag bryn1u/bryn1u:jakas_nazwa

# Usuwanie obrazow dockera. Obrazy a kontenery to dwie rozne rzeczy !
$ docker images $(docker images -q)

# Uruchomienie kontenera w tle:
$ docker run -d -ti –name donald ubuntu:latest /bin/bash

# Powrot do kontenera:
$ docker attach nazwa_kontenera

# Wyjscie z kontenera w trybie deatch:
ctrl + p + q

# Odpalamy nowy proces w kontenerze za pomoca exec:
$ docker exec -ti donald /bin/bash

# Logi dockera. wyswietli nam to co robilismy w kontenerze.
$ docker logs id_kontenera

# Uzyskiwanie nazwy kontenera przy uzyciu identyfikatora PID
$ docker ps -q | xargs docker inspect –format ‘{{.State.Pid}},{{.Config.Image}}, {{.Name}}’

# Zapisywanie pliku obrazu:
$ docker image save -o nazwa.tar repozytorium:znacznik

# Killowanie dockera za pomoca wyslania sygnalu SIGKILL
$ docker kill nazwa_kontenera

# Porownywanie roznic pomiedzy oryginalnym obrazem a dzialajacym kontenerem.
$ docker diff container_id

# Odczeka 60 sekund przed zabiciem dockera:
docker container stop -t 60 nginx3

###### Kontenery w sieci #####:

# Tworzy i binduje swoj port 80 do losowego portu np: 32768 dzieki fladze “P“:
$ docker run -it -d –name HttpdServer2 -P httpd

# Tworzy i binduje swoj port 80 do wybranego przez nas portu np 8080, dzieki fladze “p”:
$ docker run -it -d -p 8080:80 –name HttpdSever httpd

# Tworzymy polaczenie z dugim kontenerem za pomoca flagi –link nazwa_kontenera:
$ docker run –ti –name nazwa_kont –link nazwa_wczesniej_stworzoznego_kontenera bash /bin/bash

# Tworzymy siec dla dockerów o nazwie siec:
$ docker network create siec

#Tworzymy kontener i podpinamy go do sieci o nazwie siec:
$ docker run -ti –net=siec –name server2 ubuntu /bin/bash

# Wyswietlamy zawartosc sieci:
$ docker network inspect nazwa_sieci

# Wyswietlamy informacje o ip dockera za pomoca inspect:
docker inspect –format='{{.NetworkSettings.IPAddress}}’ docker_id

# Tworzymy wlasna siec rozbudowana o subnet i gateway:
$ docker network create –subnet 10.10.0.0/16 –gateway 10.10.0.1 most_sieciowy

# Tworzymy wlasna statyczna rozbudowana siec. Ograniczamy zasieg ip (–ip-range) do “5”, wyznaczamy driver czyli bridge (jest tez overlay) i podajemy nazwe sieci “bridge5”:
$ docker network create –subnet 10.10.0.0/16 –gateway 10.10.0.1 –ip-range=10.10.5.0/24 –driver=bridge bridge5

#Tworzymy docker z wlasnym ip:
$ docker run -ti -d –net bridge5 –ip 10.10.3.1 ubuntu /bin/bash

###### Volumeny Danych #####:

# Tworzymy share’owany katalog w kontenerze:
$ docker run -ti –name K1 -v /public_1 ubuntu bash

# Tworzymy drugi kontener, w ktorym bedzie dostepny kaatalog public_1 z kontenera K1:
$ docker run -ti –name K2 –volumes-from K1 ubuntu bash

# Tworzymy kontener do ktorego montujemy katalog z naszego localhostu:
$ docker run -ti -d –name WebServer0 -p 8080:80 -v “$PWD”:/usr/local/apache2/htdocs httpd

# Kopiujemy plik z naszego hosta do dockera:
$ docker cp nazwa_pliku nazwa_docker:/sciezka/gdzie/kopiujemy

# Kopiujemy odwrotnie. Z dockera na host:
$ docker cp NazwaDockera:/sciezka/gdzie/jest/plik /nasza/lokalizacja

# Tworzmy volumen:
# Volumeny sa trzymane w /var/lib/docker/volumes:
261b6f9fc910
$ docker volume create vol-test01

# Tworzymy kontener Voltest i od razu montujemy do niego volumen vol-test01, ktory stworzylismy i montujemy do /dane w srodku dockera:
$ docker run -ti –name Voltest –mount source=vol-test01, target=/dane ubuntu /bin/bash

# Wyswietlamy informacje o volume:
$ docker volume inspect nazwa_volumena

# Tworzymy volumen z opisem:
$ docker volume create –label=”To jest nasz opis” vol

# “Prune” usuwa nam te volumes, ktore nie sa uzywane:
$ docker volume prune

# “Prune” usuwamy wszystkie volumes:
$ docker volume rm $(docker volume ls -q)

# Usuwanie Dockera wraz z volumenem za pomoca opcji -v:
$ docker rm -v id_kontenera

# Montowanie volumenow z polityka selinux. Przelacznik “Z”:
$ docker run -v /etc/dhcpd:/etc/dhcpd:Z dhcpd

# Montowanie katalogu tylko w trybie odczytu dla dockera:
$ docker run –rm -ti –read-only=true -v /mnt/session:/mnt/session ubuntu:latest /bin/bash

# Montowanie zasobow tmpfs:
$ docker run –rmi -ti –read-only=true –tmpfs /tmp:rw,noexec,nodev,nosuid,size=256M ubuntu:latest /bin/bash

# Wyswietla liste volumenow, ktore nie sa uzywane przez zadne kontenery:

# Usuwa wszystkie volumeny, do ktoryh nie odwoluje sie zaden kontener:
$ docker volume rm $(docker volume ls -qf dangling=true)

$ docker volume ls -f dangling=true

# Wyswietla volumeny z okreslonym sterownikiem:
$ docker volume ls -f driver=local

# Dopasowywuje czesc lub calosc volumenu:
docker volume ls -f name=da

###### DockerFile #####:

# Budujemy wlasny image, przykladowy dockerfile:

[root@ServerLearnig Build]# cat Dockerfile
#Przykładowy dockerfile

FROM ubuntu:latest
MAINTAINER m.bryn1u
LABEL maintainer=”MB moj mail”

# Budujemy obraz. Jako nazwe podaje repo, ktore znajduje sie w moim docker hub. “.” katalog, z ktorego bedzie zbudowany docker.
docker build -t bryn1u/bryniek .

CMD / RUN – pozwala nam na uruchomienie polecenia podobnie jak RUN, tylko to polecenie jest uruchamiane podczas budowy kontenera. Natomiast RUN jest uruchamiane podczas budowy obrazu.

# Przykładowy 1 dockerfile dla apache2:

[root@ServerLearnig Build]# cat Dockerfile
FROM ubuntu:latest

RUN apt-get update && apt-get install -y apache2

ENV APACHE_RUN_USER www-data
ENV APACHE_RUN_GROUP www-data
ENV APACHE_LOG_DIR /var/log/apache2
ENV APACHE_LOCK_DIR /var/lock/apache2
ENV APACHE_PID_FILE /var/run/apache2.pidd

EXPOSE 80

CMD apachectl -D FOREGROUND

# Przykładowy 2 dockerfile dla apache2:

[root@ServerLearnig Build]# cat Dockerfile
# Dockerfile
FROM ubuntu
MAINTAINER Edek z krainy kredek

RUN apt-get update && apt-get install -y apache2 php7.2 vim nano wget libapache2-mod-php7.2 php7.2-mysql php7.2-cli && rm -rf /var/lib/apt/lists/*

RUN echo “<?php phpinfo(); ?>” > /var/www/html/info.php

EXPOSE 80

CMD apachectl -D FOREGROUND

# Wyswietlamy historie budowania warstw:
$ docker history nazwa_obrazu

###### Docker Registry #####:

# Uruchamiamy rejestr o nazwie registry:
$docker run -d -p 5000:5000 –restart=always –name registry registry:2

# Po stworzeniu registry zmieniamy nazwe hello-world, ktore sobie pobieramy.
$ docker pull hello-world
$ docker tag hello-world localhost:5000/hello-world

# Wysylamy obraz do naszego stworzonego registry.
$ docker pull localhost:5000/hello-world

# Teraz mozemy zatrzymac i usunac rejestr Docker Registry.
$ docker stop registry && sudo docker rm -v registry

# Magazynowanie Rejestr Docker Registry. Docker Registry zapisuje wszystkie dane jako volumen Dockera w systemie plikow hosta. Volumen Dockera moze byc umieszczony w sciezce /var/lib/registry
$ docker run -d -p 5000:5000 –restart=always –name registry -v `pwd`/data:/var/lib/registry registry:2

# Tworzenie docker registry z wczesniej wygenerowanym certifikatem.
# Tworzenie crt i key.
$ openssl req -newkey rsa:4096 -nodes -sha256 -keyout certs/domain.key -x509 -days 365 -out certs/domain.crt
docker run -d -p 5000:5000 –restart=always –name registry -v `pwd`/certs:/certs -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/domain.crt -e REGISTRY_HTTP_TLS_KEY=/certs/domain.key registry:2

###### CPU, Shares, Memory, I/O etc… #####:

–cpu 2 – dwa procesy obciazajace procesor. Dla stress.
–io 1 – jeden proces dla operacji I/O
–vm 2 – dwa procesy dla alokacji pamieci
–vm-bytes – rozmiar alokacji pamieci np 128M
–timeout 120s – czas trwania
–cpu-shares – dostep czasu do procka. Default jest to 1024
–cpuset=0,1,2… – dostep do rdzeni

Przestrzenie nazw: punktów montowania, UTS, IPC, PID, zasobów sieciowych i przestrzeni nazw użytkownika.

#Uwaga !! Wszystkie opcje znajdujace sie po slowie stress naleza tylko do “stress”, a nie do dockera !

# Pomiar obciazenia kontenera za pomoca “stress”:
docker run –rm -ti progrium/stress –cpu 2 –io 1 –vm 2 –vm-bytes 128M –timeout 120s

# Pomiar obciazenia za pomoca “stress”. Przydzielona polowa cpu-shares, kontener przypiety do 1 (–cpuset) z dwoch procesorow:
docker run –rm -ti –cpu-shares 512 –cpuset=0 progrium/stress –cpu 2 –io 1 –vm 2 –vm-bytes 128M –timeout 120s

# Wejscie do kontenera za pomoca nsenter:
$ nsenter –target $PID –mount –uts –ipc –net –pid

# Aby rozszerzyc uprawnienia roota w kontenerze mozna uzyc opcji privileged, dzieki temu mozemy dodawac np mac adress z pozimu kontenera:
$ run -it –rm –privileged=true ubuntu /bin/bash

# Ograniczenie ilosci procesow dla kontenera:
$ docker run –pids-limit=64

# Powyższe polecenie ustawia sztywny limit pamięci na 1 gigabajt, a następnie dla rezerwacji pamięci określa pół gigabajta. Gdy po ustawieniu tych ograniczeń kontener wykorzysta więcej niż 500 megabajtów (500M) i mniej niż 1 gigabajt (1G), Docker spróbuje zmniejszyć pamięć kontenera do poziomu poniżej 500 megabajtów:
$ docker run -it -m 1G –memory-reservation 500M ubuntu /bin/bash

# Zawartosc od 0 do 100 swappiness.
$ docker run -it –memory-swappiness=0 ubuntu /bin/bash

# Limit dla zasobow procesora wynosi 50%:
$ docker run -it –cpu-quota=50000 ubuntu/bin/bash

# W tym wypadku kontener może uzyskać 50% zasobów procesora co 50 ms.
$ docker run -it –cpu-quota=25000 –cpu-period=50000 ubuntu /bin/bash

# Przydzieli max 4 rdzenie procesora:
$ docker run -it –cpuset 4 ubuntu

# Dodatkowe ustawienia podczas uruchamiania Dockera:

–dns=8.8.8.8 mozna uzyc dwoch –dns=8.8.8.8 –dns=8.8.4.4
–mac-address=”a2:11:aa:22:bb:33″
–dns-search=ovh.com
–hostname=”nazwa”
–read-only=true montuje volumen tylko w trybie odczytu dla dockera
–tmpfs /tmp:rw,noexec,nodev,nosuid,size=256M
–cpu 2 – dwa procesy obciazajace procesor
–io 1 – jeden proces dla operacji I/O
–vm 2 – dwa procesy dla alokacji pamieci
–vm-bytes – rozmiar alokacji pamieci np 128M
–timeout 120s – czas trwania
–cpu-shares – dostep czasu do procka. Default jest to 1024
–uts=host – Przestrzen nazw UTS – Time Sharing System
–net=host – docker pracuje, wtedy w przestrzeni nazw sieci serwera.
–privileged=true – zwieksza uprawnienia w kontenerze, mozna np dodac mac address z poziomu kontenera
–pids-limit=64 – ogranicza ilosc procesow dla kontenera. Ograniczna np forkbombe.
–cidfile=”” – kontener moze zapisac swoj numer pid w wybranym pliku
–log-driver=syslog – ustawienia sterownika logowania np: docker run –log-driver=syslog ubuntu
–log-opt max-size=[0-9+][k|m|g] – max wielkosc logu, zamiast syslogd mozna uzyc journald
–log-opt max-file=[0-9+] – max ilosc plikow
–memory – ustawia ilosc pamieci ram
–memory-swap – domyslnie przypisuje dwa razy wieksza wartosc –memory
–time (-t)- czas oczekiwania przed wyslaniem sygnalu SIGKILL. Defaultowoo to 10 sekund

###### Capabilities… #####:

# Zeby nadac dockeroowi uprawnienia do modyfikacji “sieci” dodajemy NET_ADMIN:
$docker run -it –cap-add=NET_ADMI ubuntu /bin/bash

# Zeby “zrzucic” uprawnienia CAP uzywamy –cap-drop:
$docker run -it –cap-drop=NET_ADMIN ubuntu /bin/bash

# Trobuleshooting:

– podczas montowania dysku w kontenerze moze pojawic sie blad “Permission Denied”:
$ chcon -Rt svirt_sandbox_file_t /katalog

ZOSTAW ODPOWIEDŹ

Please enter your comment!
Please enter your name here