213 lines
8.0 KiB
Markdown
213 lines
8.0 KiB
Markdown
# 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
|
|
```
|