# Comandi ## Immagini ### Ricerca sul registry ```bash docker search 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 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 :tag` oppure `docker rmi `. 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 :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 4 days ago ENTRYPOINT ["docker-entrypoint.sh"] 0B buildkit.dockerfile.v0 4 days ago COPY docker-entrypoint.sh /usr/local/bin/ # … 388B buildkit.dockerfile.v0 4 days ago RUN /bin/sh -c set -ex && export GNUPGHOME… 5.34MB buildkit.dockerfile.v0 4 days ago ENV YARN_VERSION=1.22.22 0B buildkit.dockerfile.v0 4 days ago RUN /bin/sh -c ARCH= && dpkgArch="$(dpkg --p… 192MB buildkit.dockerfile.v0 4 days ago ENV NODE_VERSION=24.4.1 0B buildkit.dockerfile.v0 4 days ago RUN /bin/sh -c groupadd --gid 1000 node &&… 8.94kB buildkit.dockerfile.v0 18 months ago RUN /bin/sh -c set -ex; apt-get update; ap… 588MB buildkit.dockerfile.v0 18 months ago RUN /bin/sh -c set -eux; apt-get update; a… 177MB buildkit.dockerfile.v0 2 years ago RUN /bin/sh -c set -eux; apt-get update; a… 48.4MB buildkit.dockerfile.v0 2 years ago # debian.sh --arch 'amd64' out/ 'bookworm' '… 117MB debuerreotype 0.15 ``` Un ulteriore comando per ispezionare un'immagine é `docker inspect :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 ``` ### 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, utilizzare il comando: ```bash docker rm docker rm ``` Per eliminare automaticamente un container al termine della sua esecuzione, esiste invece il comando: ```bash docker run --rm -it --name ubuntu ubuntu bash ``` #### 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 docker stop ``` Per avviarlo nuovamente: ```bash docker start docker start ``` #### 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 ```