# Comandi

## Immagini

### Ricerca sul registry

```bash
docker search <image_name>

docker search ubuntu
```

### Scaricare un'immagine

Per scaricare un'immagine, si utilizza il comando `docker pull`, specificando il nome dell'immagine e, se necessario, il `tag` per una versione specifica. Se il `tag` non è specificato, verrà scaricata l'ultima versione disponibile, indicata come `latest`. È possibile avere più versioni della stessa immagine sullo stesso sistema.

```bash
docker pull <image_name>

docker pull ubuntu

docker pull nginx:stable
```

Quando si scarica un'immagine, il terminale mostrerà un output simile al seguente:

```txt
docker pull node:latest

latest: Pulling from library/node
c19952135643: Pull complete
7bbf972c6c2f: Pull complete
900e2c02f17f: Pull complete
abe9c1abe6f3: Pull complete
09461c05d868: Pull complete
16707a187717: Pull complete
2b24aa75a958: Pull complete
74d4dfcbaa69: Pull complete
Digest: sha256:601f205b7565b569d3b909a873cc9aa9c6f79b5052a9fe09d73e885760237c4c
Status: Downloaded newer image for node:latest
```

Ogni hash rappresenta un layer che compone l'immagine, il quale introduce una modifica rispetto all'immaigne base.

### Lista e rimozione delle immagini

```bash
docker image ls

docker image ls
REPOSITORY   TAG       IMAGE ID       CREATED      SIZE
node         latest    2c85757b0aae   4 days ago   1.13GB
```

Questo comando fornisce, per ogni immagine scaricata, e per ogni versione, un resoconto. L'attributo della colonna `CREATED` indica quando l'immagine é stata creata dal suo autore, non quando l'abbiamo scaricata.

Per rimuovere un'immagine specifica, esiste invece il comando `docker rmi <image_name>:tag` oppure `docker rmi <image_id>`.

Per rimuovere invece tutte le immagini, eccetto quelle utilizzate da container avviati o stoppati, si utilizza il comando `docker image prune`.

### History

Il comando `docker history <image_name>:tag` ripercorre le istruzioni del Dockerfile utilizzate per costruire l'immagine indicata. Ad esempio:

```bash
docker history node:latest

IMAGE          CREATED         CREATED BY                                      SIZE      COMMENT
2c85757b0aae   4 days ago      CMD ["node"]                                    0B        buildkit.dockerfile.v0
<missing>      4 days ago      ENTRYPOINT ["docker-entrypoint.sh"]             0B        buildkit.dockerfile.v0
<missing>      4 days ago      COPY docker-entrypoint.sh /usr/local/bin/ # …   388B      buildkit.dockerfile.v0
<missing>      4 days ago      RUN /bin/sh -c set -ex   && export GNUPGHOME…   5.34MB    buildkit.dockerfile.v0
<missing>      4 days ago      ENV YARN_VERSION=1.22.22                        0B        buildkit.dockerfile.v0
<missing>      4 days ago      RUN /bin/sh -c ARCH= && dpkgArch="$(dpkg --p…   192MB     buildkit.dockerfile.v0
<missing>      4 days ago      ENV NODE_VERSION=24.4.1                         0B        buildkit.dockerfile.v0
<missing>      4 days ago      RUN /bin/sh -c groupadd --gid 1000 node   &&…   8.94kB    buildkit.dockerfile.v0
<missing>      18 months ago   RUN /bin/sh -c set -ex;  apt-get update;  ap…   588MB     buildkit.dockerfile.v0
<missing>      18 months ago   RUN /bin/sh -c set -eux;  apt-get update;  a…   177MB     buildkit.dockerfile.v0
<missing>      2 years ago     RUN /bin/sh -c set -eux;  apt-get update;  a…   48.4MB    buildkit.dockerfile.v0
<missing>      2 years ago     # debian.sh --arch 'amd64' out/ 'bookworm' '…   117MB     debuerreotype 0.15
```

Un ulteriore comando per ispezionare un'immagine é `docker inspect <image_name>:tag`, il quale specifica le variabili d'ambiente, l'`entrypoint`, ossia il programma eseguito all'avvio del container, i vari layer, ecc.

## Container

### Esecuzione di un container Docker

Quando si esegue il comando `docker run ubuntu`, non si osserva alcun output apparente. Questo comportamento è dovuto al fatto che quella di ubuntu è un'immagine base, priva di un entrypoint che avvii un servizio in esecuzione, causando la terminazione immediata del container. Per eseguire una shell interattiva all'interno del container, è possibile utilizzare il comando:

```bash
docker run ubuntu bash
```

Tuttavia, anche in questo caso non verrà visualizzato alcun output, poiché Docker, per impostazione predefinita, non collega il terminale corrente al processo in esecuzione. Per collegare il terminale al processo `bash` all'interno del container, è necessario utilizzare il parametro `-it`, che sta per *interactive terminal*. Il comando diventa quindi:

```bash
docker run -it ubuntu bash
```

A questo punto, si otterrà un prompt simile al seguente:

```bash
root@a9c42c663b02:/#
```

dove `a9c42c663b02` rappresenta l'ID del container in esecuzione.

Ogni volta che si esegue il comando `docker run`, viene creato un nuovo container con un ID univoco. È possibile assegnare un nome specifico al container utilizzando l'opzione `--name`, come mostrato di seguito:

```bash
docker run -it --name ubuntu ubuntu bash
```

Per uscire dal container, si può digitare `exit` o premere la combinazione `CTRL+D`, il che comporterà la chiusura del container. In alternativa, utilizzando la combinazione `CTRL+P CTRL+Q`, si può uscire dal container mantenendolo attivo in background.

Per verificare lo stato dei container in esecuzione, si può utilizzare il comando:

```bash
docker container ls

CONTAINER ID   IMAGE     COMMAND   CREATED         STATUS         PORTS     NAMES
a9c42c663b02   ubuntu    "bash"    3 minutes ago   Up 3 minutes             romantic_agnesi
```

Per ricollegarsi a un container già in esecuzione, si utilizza il comando:

```bash
docker attach <container_id>
```

### Gestire i container

I container non sono realmente effimeri: quando un container viene arrestato, il suo contenuto non viene perso. È possibile riavviare un container fermato e recuperare qualsiasi dato generato al suo interno. Per eliminare un container e le relative informazioni, è necessario eseguire un'operazione esplicita.

#### Rimozione dei container

Per rimuovere un container non in esecuzione, utilizzare il comando:

```bash
docker rm <container_id>

docker rm <container_name>
```

Il flag `-f` forza la rimozione di un container, anche qualora fosse in esecuzione.

Per eliminare automaticamente un container al termine della sua esecuzione, esiste invece il comando:

```bash
docker run --rm -it --name ubuntu ubuntu bash
```

Il comando `docker container prune` eliminerá tutti i container non in esecuzione.

#### Elencare i container

Il comando `docker ps` restituisce l'elenco dei container attualmente in esecuzione. Aggiungendo il flag `-a`, è possibile visualizzare anche tutti i container non in esecuzione.

#### Arrestare e avviare un container

Per fermare un container, utilizzare il comando

```bash
docker stop <container_id>

docker stop <container_name>
```

Per fermare forzatamente un container e liberare le risorse utilizzate, esiste l'opzione `kill`.

Per avviarlo nuovamente:

```bash
docker start <container_id>

docker start <container_name>
```

#### Modalità detached

Quando si esegue il comando `docker run ubuntu sleep 60`, la shell rimane occupata fino al termine dell'esecuzione del comando. Per lanciare container in modalità *detached*, che consente di liberare la shell, utilizzare il flag `-d`:

```bash
docker run -d ubuntu sleep 60
```

### Concatenazione di comandi

Per eseguire più comandi all'interno di un container Docker, è possibile utilizzare la seguente sintassi:

```bash
docker run --rm -it ubuntu bash -c "sleep 5; ls -lh"
```

### Lettura dei Log

Il comando seguente consente di visualizzare i log di un container in tempo reale:

```bash
docker logs -f <container_id>

docker logs -f <container_name>
```

### Utilizzo delle risorse

Per limitare l'uso delle risorse da parte di un container, è possibile specificare il numero massimo di core CPU e la quantità di memoria RAM utilizzabile. Utilizzando i parametri `--cpus` e `--memory`, si può evitare che il container saturi le risorse del sistema.

```bash
docker run --rm -it --cpus 2 --memory 1024m --name ubuntu ubuntu
```
