Docker - ghdrako/doc_snipets GitHub Wiki

docker --version
docker version  # more info
docker info     # more more info where is root directory and default registry

docker images
docker images -q # quite display only id images
docker history <image> # lista polecen z Dockerfile ktore utworzyly image
docker history --format "{{.ID}} {{.CreatedBy}} {{.Size}}" ansible
docker rmi -f $(docker images -a -q)  # usuniecie wszystkich obrazow

docker search python
docker search --filter is-official=true python
docker search --help
wget -q https://registry.hub.docker.com/v1/repositories/debian/tags -O -  | sed -e 's/[][]//g' -e 's/"//g' -e 's/ //g' | tr '}' '\n'  | awk -F: '{print $3}'

$ docker port <container>  # show port number assigment

docker image pull alpine
docker image ls
docker image rm alpine
docker image rm -f $(docker image ls -q) # remove all images you have localy

docker container run alpine echo "hello my first container"
docker container run alpine --name myfirstcontainer
docker container rm d99b153cf127
docker container rm xenodochial_stonebraker
docker container rm -f (docker container ls -aq) # remove all container you have on host

docker build -f Dockerfile1 -t api:v1 .
```
```
docker container run -d -it --name test1 ubuntu /bin/bash #  -d option - to run the container in the background as daemon or detached mode
docker run -i -t ubuntu:20.04 /bin/bash  # Run a container and connect it to its command line
docker run -d -t ubuntu:20.04  # run container in background but not attach console to it
docker run -itd -p 9090:8080 api:v1
docker run -itd --rm -p 9090:8080 api:v1  # -rm remove continer after exit
docker run -itd --rm --name <container_name> -p 9090:8080 api:v1  # -name <container_name> assign name - by defaut random name 
docker run -d --name container-name alpine watch "date >> /var/log/date.log" #
```
```
docker exec -it <container hash/name> sh   # start in container another process - in examle comman line sh
docker exec -it <container hash/name> /bin/bash # wystartowanie i uruchomienie powloki w kontenerze -t otwarcie teminala -i interaktywne wprowadzanie polecen
docker exec container-name tail /var/log/date.log  # running no interactive command on container
docker exec --workdir /tmp container-name pwd # Running Commands in an Alternate Directory in a Docker Container
docker exec --user guest container-name whoami # Running Commands as a Different User in a Docker Container
docker exec -e TEST=sammy container-name env # Passing Environment Variables into a Docker Container
docker exec -e TEST=sammy -e ENVIRONMENT=prod container-name env
docker exec --env-file .env container-name env
```
```
docker attach <container hash/name> # attach to container pocess
CTRL-p CTRL-q #  detach from container and leave it running
```
```
docker run <image> python -c 'print("Hello")'
docker run --restart=always redis #  restart policy of always so that if the container exits, Docker will restart it.

curl -k http://localhost:9090/encode?input=test

docker container run -d -it --name test1 ubuntu /bin/bash
docker container ls
docker container attach test1
$> apt-get update
$> apt-get install curl
$> exit
docker container commit test1 testimage # create image from modified container
docker image ls

Dockerfile:
FROM ubuntu:latest
RUN apt-get update && apt-get install curl -y

docker image build -t testimagedockerfile .
docker image ls
docker container run -it testimagedockerfile
$> which curl
$> exit

docker image tag testimagedockerfile <DH user>/testimagedockerfile
docker image ls
docker login
docker image push <DH user>/testimagedockerfile

docker rename <container id> ansible  # zmiana 
docker inspect
docker inspect | jq keys
docker inspect | jq .[0] | jq keys
docker inspect ansible| jq .[0].ResolvConfPath

docker rm $(docker ps -a -l -q -f status=exited) # usun ostatni wylaczony kontener
                                name=python       # kontenery o nazwie python
                                ancestor=python   # kontenery pochodace od image python

docker rm $(docker ps -a -q --filter before=$(docker ps -a -l --format {{.Name}})) # usun wszystkie poza ostatnim

docker ps -a  to to samo co docker container ls -a

-f  # force
docker rmi -f $(docker images -q)  # remove all images

$ docker rm  $(docker ps -a -q -f status=exited)

$ docker rm -f <container_name> # remove a container even if it run (uses SIGKILL)

$ docker volume create data
$ docker run --name test123 -v data:/data -d busybox  ping google.com
$ docker attach --detach_keys="ctrl-a"  test123
```
#### inspect
* --format option
* --filter option
```
docker image ls --filter dangling=true #  filter the dangled images only
```

```
docker image inspect –format='{{.Architecture}} {{.Os}}' <image-id> #  get the architecture and operating system an image
docker inspect $(docker ps -a -q --filter ancestor=busybox) |jq .[0].NetworkSettings.IPAddress # show container ip
docker inspect -f '{{.NetworkSettings.IPAddress}}' $(docker ps -a -q --filter ancestor=busybox)
pid =$(docker inspect -f '{{.State.Pid}} <contener>)
strace -p $(pgrep -P $pid)
#aby bylo mozliwe sledzenie wywolan systemowych kontenera z hosta, kontener musi byc urchomiony z opcja --pid=host

docker inspect -f {{.nazwa}} <kontener>  # wyswietlic okreslone pole

docker logs [OPTIONS] CONTAINER
docker logs 7d6ac83a89a0
docker logs -f 7d6ac83a89a0 # continue streaming the new output from the container’s 
docker logs -t 7d6ac83a89a0 # show timestamps
docker logs -n 10 -n 7d6ac83a89a0 # Number of lines to show from the end of the logs
# docker logs = docker container logs 
docker container logs --since 2020-03-28T15:52:00 nginx-test

docker top nginx-test
docker stats nginx-test

Endpoint /containers/<id kontenera>/stats # dostarcza dane statystyczne o działajacym kontenerze
docker run --name running -d busybox /bin/sh -c 'while true; do echo hello && sleep 1; done'
docker stats running

docker container run -d --name nginx-test --cpu-shares 512 --memory 128M -p 8080:80 nginx
docker container update --cpu-shares 512 --memory 128M nginx-test  # modify to running container
docker run -it --memory="1g" -cpus="1.0" ubuntu # run ubuntu container set limit memory 1GB and acces to 1 CPU

for i in {1..5}; do docker container run -d --name nginx$(printf "$i") nginx; done

docker container run -it --name test ubuntu /bin/bash  # -it  interactive terminal to interact with the container and run
commands inside it

docker container ls # list running containers
docker container ls -a # list all container , exited too


docker container pause nginx1
docker container unpause nginx1

docker container stop nginx2  # terminate container status=exited
docker container stop -t 60 nginx3 # send SIGTERM wait 60s send SIGKILL
docker container start nginx2 # resume terminated container
docker container restart nginx2 # combine two command stop and start Jest opcja  -t 60 
docker container kill nginx5 # send SIGKILL

docker container rm nginx4 # remove specific container

docker container create --name nginx-test -p 8080:80 nginx # prepare container but not start
docker container port nginx-test # display port maping in container

docker container diff nginx-test # lista plikow zmienianych(C, dodanych(A)

docker export <id contenera> > /home/docker/myimage.tar   # nie jest zapisywana historia warstw i to odchudza kontener
docker export <id contenera> | docer import slim_container

docker system prune #  clean all unused objects in one go
docker system prune  --volumes #  clean all unused objects in one go include the volumes

docker container prune
docker image prune
docker buildx prune
docker network prune

{
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "20m",
    "max-file": "10",
  }
}

hello.py:
import os
print "Hello World from %s !" % os.environ['NAME']

docker build -t hello_world_python_name .

docker run -e NAME=Rafal hello_world_python_name

Dockerfile
...
ENV NAME Rafal
...

cat /home/docker/myimage.tar | docker import - <image name>

docker commit <id-contenera> <image-name>