{"id":24772550,"url":"https://github.com/gerryp92/guidaadocker","last_synced_at":"2026-05-18T14:36:46.939Z","repository":{"id":274312420,"uuid":"922322147","full_name":"Gerryp92/GuidaADocker","owner":"Gerryp92","description":"Guida rapida e pratica a Docker","archived":false,"fork":false,"pushed_at":"2025-01-26T21:13:17.000Z","size":707,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-03-23T20:45:03.200Z","etag":null,"topics":["container","docker","docker-compose","dockerfile"],"latest_commit_sha":null,"homepage":"","language":"Dockerfile","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Gerryp92.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2025-01-25T22:18:43.000Z","updated_at":"2025-01-26T21:13:20.000Z","dependencies_parsed_at":"2025-01-26T14:39:36.344Z","dependency_job_id":null,"html_url":"https://github.com/Gerryp92/GuidaADocker","commit_stats":null,"previous_names":["gerryp92/guidaadocker"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Gerryp92%2FGuidaADocker","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Gerryp92%2FGuidaADocker/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Gerryp92%2FGuidaADocker/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Gerryp92%2FGuidaADocker/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Gerryp92","download_url":"https://codeload.github.com/Gerryp92/GuidaADocker/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":245168812,"owners_count":20571799,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["container","docker","docker-compose","dockerfile"],"created_at":"2025-01-29T04:23:18.531Z","updated_at":"2025-10-29T10:12:33.815Z","avatar_url":"https://github.com/Gerryp92.png","language":"Dockerfile","funding_links":[],"categories":[],"sub_categories":[],"readme":"# GuidaPraticaADocker\n\n## Come scaricare una immagine docker e primi passi\nSe vuoi scaricare una immagine da docker hub, utilizza il comando:\n```bash\ndocker pull “immagine”\n```\nEsempio:\n```bash\ndocker pull ubuntu\n```\n\nSe voglio far partire un container dall’immagine precedentemente scaricata:\n```bash\ndocker run -itd ubuntu:latest /bin/bash\n```\nil comando si articola con diversi parametri\n#### itd : \n- t significa di creare una pseudo tty per lanciare comandi\n- i significa tiene aperto lo stdin, ovvero lo standard input\n- d significa detach, quindi da la possibilità di lancia il container in background\n\nUbuntu:latest dice a docker di andare a cercare questa immagine dal registry locale, se non c’è va a scaricarlo da docker hub\n\n*/bin/bash* è l’entrypoint ovvero il comando che viene lanciato subito dopo lo start del container\n\n**[NOTA: l’entry point avrà sempre PID 1]**\n\nSe io voglio uscire dal container senza mandare in exited il container devo digitare CTRL+P+Q oppure digitare exit\n\nLanciando il comando docker ps -a, possiamo vedere tutti i container attivi e non:\n\n![Immagine1](immagini/Immagine1.png)\n\nCon il comando docker ps invece vedrò solo i docker attivi\n\n#### Container in stato “running”\n-\tSe voglio lanciare un comando su un container in stato “running” ma io sono fuori dal container posso usare il comando docker exec, esempio:\n```bash\ndocker exec -it fervent_edison /bin/bash\n```\n## Creazione dei container, alcuni comandi fondamenti:\n- Il comando **start** avvia un container in stato *stopped*\n- Il comando **stop** arresta un container in stato *started* ( non si perde il contenuto del file system )\n- Il comando **restart** riavvia un Container ( non si perde il contenuto del file system )\n- Il comando **pause** mette in pausa il container  ( non si perde il contenuto del file system e neanche lo stato dei processi )\n- Il comando **unpause** rimette in start un container in stato pause\n\n## Informazioni sui comandi docker\n```bash\nDocker --help\n```\n\n## Cancellare i container\n```bash\ndocker rm “nome container/id container”\n```\n## Comandi exec e attach\n\nSe voglio lanciare un comando dentro un container allora posso usare il comando **exec**, ad esempio:\n```bash\ndocker exec -it “nome container” comando\n```\nAlcuni esempi:\n```bash\ndocker exec -it fervent_edison ls\ndocker exec -it fervent_edison /bin/bash\n```\nSe invece voglio entrare nell’entry point già creato del container in stato running posso utilizzare il comando **attach**, come\n```bash\nDocker attach “nome container”\n```\nPer essere precisi attach (docker attach) servono per collegare stdin,stderr e stdout della macchina locale sul container\n\n## Salvataggio File sui container\nSe io salvo un file su un container, il file rimarrà nel suo file system anche se il container è in stato Exited.\n\n## Visualizziamo i log di un container\n\n```bash\nDocker logs “nome container”\n```\nPosso vedere l’ultimo “print” stampato dal container anche se è in stato stopped\n\n## Eliminare o stoppare in maniera massiva i container\n\n1. Elimiare tutti i container docker ( se possibile )\n1. Elimiare tutti i container docker ( se possibile )\n\n```bash\nDocker rm $(docker ps -a -q)\n```\nInfatti, questo comando serve per eliminare un container:\n**Docker rm** mentre, **$(docker ps -a -q)** mi da una lista di tutti i container presenti.\nQuindi il risultato sarà eliminare tutti i container presenti.\n\n**[Attenzione]** Se un container è in stato **run** questo non sarà eliminato da Docker\n\n2.  Si possono fare anche eliminazioni \"mirate\", ad esempio eliminare tutti i container in stato \"exited\"\n\n```bash\nDocker rm $(docker ps -a -f status=exited -q)\n```\n\n3. Eliminare tutte le immagini ( se possible )\n\n2.  Si possono fare anche eliminazioni \"mirate\", ad esempio eliminare tutti i container in stato \"exited\"\n\n```bash\nDocker rm $(docker ps -a -f status=exited -q)\n```\n\n3. Eliminare tutte le immagini ( se possible )\n\n```bash\nDocker rmi $(docker ps -a -q)\n```\n\n\nInfatti, questo comando serve per eliminare una immagine:\n**Docker rmi** mentre **$(docker images -a -q)** mi da una lista di tutti i container presenti.\nQuindi il risultato sarà eliminare tutti i container presenti.\n\n## Networking in Docker\n\nDi default docker crea una interfaccia di rete chiamata Docker0 in bridge ethernet, tutti i container saranno agganciati a quell'interfaccia e\ndocker engine penserà al routing. \nViene assegnato al container un ip della subnet definita (di solito 172.17.0.0/16) , questa network essendo in una rete virtuale e confinata dal docker engine potrà:\n- Raggiungere l'esterno\n- Non potrà essere raggiunta dall'esterno\n\n\nSe voglio vedere le network in docker:\n\n```bash\ndocker network ls\n```\n![Immagine3](immagini/Immagine3.png)\n\nSe voglio vedere i dettagli della rete docker in particolare, posso farlo con il comando **inspect**\ncon l'id della rete.\n\n![Immagine4](immagini/Immagine4.png)\n\n**Nota:**\nAnche se è in bridge, la rete docker e la rete fisica sono diverse:\n\n![Immagine5](immagini/Immagine5.png)\n\nSupponiamo di voler installare Apache per avere un server web:\n\n```bash\nDocker pull httpd\nDocker run -itd –name: ApacheTest -p 8080:80 httpd\n```\n\nIl **parametro -p è fondamentale** perché \u003cu\u003e consente di mappare la porta del rete docker sulla rete locale \u003c/u\u003e\n\nCome si vede anche dal docker ps -a nella sezione PORTS, tutto il traffico della rete locale della porta 8080 viene mappata sulla porta 80 del container\n\n![Immagine6](immagini/Immagine6.png)\n\nVisto che le 2 reti sono separate ( rete docker e rete fisica ) ho 2 modi per vedere il funzionamento.\nLa prima è utilizzando la rete docker e la porta 80 e il comando curl\n\n![Immagine7](immagini/Immagine7.png)\n\nLa seconda è utilizzando la rete fisica con la mappatura della porta 8080-\u003e80 del container e il comando curl\n\n![Immagine8](immagini/Immagine8.png)\n\nOvviamente, nel secondo caso si può usare anche l’interfaccia web della rete fisica\n\n![Immagine9](immagini/Immagine9.png)\n\n**Di seguito uno schema di quanto fatto:**\n\n![Immagine10](immagini/Immagine10.png)\n\nAbbiamo visto che il docker engine crea una separazione tra le 2 reti, quella dei container e la nostra rete fisica. \nMa come posso fare per avere un container sulla “rete fisica”?\n\nCi sono 2 possibilità, in base alle necessità:\n\nutilizzando l’opzione **--network host**\n\nutilizzando l’opzione **–network macvlan**\n\n#### Ipotesi 1: \n**--network host** , serve per posizionare il container sul nostro host\nVerifichiamolo con il nostro server web Apache\n\n```bash\nDocker run -itd --network host –name: ApacheTest1 -p 8080:80 httpd\n```\n\n![Immagine11](immagini/Immagine11.png)\n\nNotiamo che non è presente più nulla nella sezione ports e infatti se faccio curl localhost:80\nPosso notare che il container è raggiungibile dalla rete locale, perché esso stesso è sulla rete locale\n\n![Immagine12](immagini/Immagine12.png)\n\n#### Ipotesi 2 : \n**--network macvlan** \n\nSe desideriamo invece che il container abbia un indirizzo ip della stessa network dell'host dobbiamo creare un'interfaccia di rete\nutilizzando il driver macvlan.\nIn questa situazione, puoi utilizzare il driver di rete macvlan per assegnare un indirizzo MAC all'interfaccia di rete virtuale di ogni contenitore,\nfacendo sembrare che sia un'interfaccia di rete fisica direttamente collegata alla rete fisica.\nQuesto può essere molto utile sopratutto per software legacy, in quanto alcuni programmi vogliono assocciare l'interfaccia di rete fisica direttamente alla rete fisica.\n\n\n-\u003e Creiamo un rete MACVLAN\n\nIn teoria dobbiamo assegnare una rete fuori dalla rete con indirizzi assegnati dal DHCP\n\n```bash\ndocker network create -d macvlan   --subnet=192.168.4.0/24   --gateway=192.168.4.10  -o parent=”interfaccia di rete” rete_macvlan\ndocker run -d --network=rete_macvlan --name ApacheTest2 httpd:latest\n```\n\n**NOTA=** il docker engine non riuscirà a raggiungere i container sulla rete fisica, solo gli altri host della stessa rete ci riusciranno\n**NOTA2=** come nel caso precedente non c’è bisogno del port-forwarding infatti la porta è accessibile direttamente dalla rete fisica\n\nSupponiamo che ora vogliamo assegnare un indirizzo ip fisso al mio container, nel caso seguente assegnerò 192.168.4.1\n\n```bash\ndocker run -d --network=rete_macvlan –-ip 192.168.4.1 --name ApacheTest3 httpd:latest\n```\n## Gestione dei dati\n\nEsistono 2 modi per gestire i dati dei container: VOLUME e BIND Mount\n\nVOLUME:\n\nIl metodo consigliato per la persistenza dei dati in generale sono i Named Volume, quando è possibile quindi si consiglia di Volume.\nI volumi di default si trovano sulla Macchina host nel seguente percorso: **/var/lib/docker/volumes**\n1. Per creare un volume: **docker volume create “nome-volume”**\n```bash\nEs: docker volume create VolumeTest\n```\n2. Per vedere i dettagli di un volume: **docker inspect “nome-volume”**\n```bash\nEs: docker volume inspect VolumeTest\n```\n3. Per vedere i volumi presenti:  **docker inspect “nome-volume”**\n```bash\nEs: docker volume ls\n```\n4. Per eliminare un volume: **docker volume rm “nome-volume”**\n```bash\nEs: docker volume rm VolumeTest\n```\nDa un certo punto di vista possiamo pensare ai volumi con ad un di directory, ad esempio:\n```bash\ndocker run -d --name ApacheTest3 -p 8080:80 -v VolumePerApache:/usr/local/apache2/htdocs httpd\n```\n## BIND MOUNT\nSi può usare anche il bind mount, simile al volume ma molto meno flessibile perché ti consente di collegare direttamente un file o directory tra host e container, è un mount tra file, ad esempio\n```bash\ndocker run -d --name ApacheTest3 -p 8080:80 -v ./index.html:/usr/local/apache2/htdocs/index.html httpd\n```\ndove **./index.html** indica cartella corrente e il file specifico index.html\n\n## Immagine e Build\n\nLa creazione di una immagine è un aspetto fondamentale in docker.\nInfatti dalle immagine vengono poi generati i container che saranno utilizzati.\n\nSe vogliamo creare nuovi immagini, invece che scaricarle dal registry, ci sono 2 modi\n- comando **docker commit** ( a partire da un container esistente )\n- Manualmente con un dockerfile ( consigliato )\n\n\n#### Opzione 1. Usare Docker commit\nDocker commit \u003ccontainer\u003e \u003cimage \u003e\nCrea una immagine nuova a partire da un container esistente ( si può usare anche come backup )\nperò l’immagine non conterrà i dati dei volumi montati e il container verrà messo in pausa\nSupponiamo che voglia congelare il container nginx_test, usiamo:\n```bash\ndocker commit nginx_test nginx_immagine \n```\nfacendo un docker images, vedo l’immagine creata:\n\n![Immagine13](immagini/Immagine13.png)\n\nSe faccio un docker run dall’immagine indicata ho il risultato indicato\n![Immagine13](immagini/Immagine13.png)\n\nE se volessi usare questo container in un altro docker engine? \nPosso esportare l’immagine con:\n```bash\ndocker save nginx_modificato \u003e ngnix_modificato.tar\n```\nPer importarlo in un altro docker engine utilizziamo docker load:\n```bash\nDocker load \u003c nginx_modificato.tar\n```\n\n#### Opzione 2. Usare Dockerfile \n\nUn Dockerfile è scritto in linguaggio DSL, ovvero un insieme di istruzioni per costruire l’immagine.\n\n**ISTRUZIONE FROM** : E' la più importante: definisce il container (layer di partenza)\n\n**COMMENTI**: Si usa il carattere #\n\n**ENV** : Imposta variabili d'ambiente valide solo per il contesto Dockerfile (durante la build)\n\nEs: ENV nome-variabile=valore\n\n**WORKDIR**: vale solo nel contesto Dockerfile e definisce la directory di lavoro per tutti i comandi successivi come: \n\nCMD, ENTRYPOINT, COPY E ADD\n\n**RUN**: E' un comando che esegue un comando durante la build e GENERA UN NUOVO LAYER\n\n**ADD** e **COPY**: Aggiungono file all'immagine ma ADD non ha il supporto per i file remoti e gli archivi\n\n**LABEL**: Aggiunge dei metadati (etichette) all'immagine, es: mantainer, o versione (non è legato alla definizione dell'immagine)\n\n**ENTRYPOINT**: Esegue un comando nel container nonappena viene avviato\n\n**EXPOSE**: Si usano per definire quali porte saranno in ascolto in runtime, non apre porte ma prepara il forwarding\n\n**VOLUME**: E' un'etichetta di coume esterno che sarà montato dall'host o dal container, poi quando faremo il run decideremo dove montarlo.\n\nNota importante: Bisogna cercare di evitare di usare il comando RUN in molti passaggi nel dockerfile, infatti RUN genera un nuovo layer in un container.\nSe lo utilizzo n volte, avrà n nuovi layer e quindi in mio container diventerà molto importante a livello di dimensioni.\n\nSupponiamo di avere un dockerfile formattato ad hoc, con i comandi di cui sopra.\n\nPer andare a costruire una immagine a partire dal dockerfile, basta digitare:\n\n```bash\ndocker build -f \"percorso_file\" -t “nome immagine:latest”\n```\nSe invece voglio buildare un dockerfile presente nella cartella corrente:\n```bash\ndocker build . -t “nome immagine:tagversione”\n```\nEsempio: \n\n```bash\ndocker build . “myimage:0.1”\n```\n\nIpotesi di un docker file:\n\n```bash\nFROM ubuntu:latest            #Definisce l’immagine di partenza\nRUN apt get update\t\t\t      #Svolge delle operazioni sopra il livello corrente del container\nCMD[“echo”,”ciao mondo”]\t    #Esegue un comando predefinito del container. Ci può essere un solo comando CMD\n```\n\nE supponiamo di voler fare una build di questa immagine con il dockerfile in questa cartella:\n\n```bash\nDocker build . prova:0.1\n```\nSe voglio inviarla su docker hub, basta fare un push\n\n```bash\nDocker push ProfiloDocker/NomeImmagine:tag\n```\nDOCKER COMPOSE:\n\nSe si vuole fare in modo di avviare più container o servizi si può usare **docker compose**:\nTi consente tramite un file *.yaml di avviare una configurazione specifica.\n\nSe sei nella cartella di quel determinato file .yaml allora puoi fare:\n```bash\ndocker compose up  #per attivare tutto\n```\nSe vuoi avviarlo in modalità detach: \n```bash\ndocker compose up -d\n```\nServe se vuoi arrestare ed eliminare tutti i container, i network e i volumi creati da un file:\n```bash\ndocker compose down \n```\nPassiamo a degli esempi pratici, nella cartella EsempiDocker ce ne sono 2 che sottolineano la potenza di questo strumento.\nNella cartella Esempio Wordpress vediamo come è composto il file .yaml\n\n```bash \n\nservices:\n\n  wordpress:\n    image: wordpress\n    restart: always\n    ports:\n      - 8080:80\n    environment:\n      WORDPRESS_DB_HOST: db\n      WORDPRESS_DB_USER: exampleuser\n      WORDPRESS_DB_PASSWORD: examplepass\n      WORDPRESS_DB_NAME: exampledb\n    volumes:\n      - wordpress:/var/www/html\n  db:\n    image: mysql:8.0\n    restart: always\n    environment:\n      MYSQL_DATABASE: exampledb\n      MYSQL_USER: exampleuser\n      MYSQL_PASSWORD: examplepass\n      MYSQL_RANDOM_ROOT_PASSWORD: '1'\n    volumes:\n      - db:/var/lib/mysql\n\nvolumes:\n  wordpress:\n  db:\n```\n\nIn questo file yaml sono presenti 2 servizi, ovvero sarà fatto il deploy di 2 container\nIl servizio Wordpress e il servizio MySql con il comando seguente.\nI 2 container saranno lanciato con tutto quello che serve le variabili d'ambiente e i volumi che contengono i dati\n\n```bash\ndocker compose up -d\n```\nUn altro esempio ancora più interessante è il caso presente di EsempioMulti.\nIn questo caso verranno avviati 2 container nginx.\n```bash\nservices:\n  sito_base:\n    image: nginx\n    volumes:\n     - Volume1:/etc/nginx/templates\n    ports:\n      - \"8080:80\"\n    container_name: sito_base\n\n  site1:\n    build:\n      context: ./sito1\n      dockerfile: Dockerfile\n    container_name: sito1\n    volumes:\n       - Volume2:/usr/share/nginx/html\n    ports:\n      - \"8081:80\"\n```\nIl primo container è un classico server web ngnix con port forwarding della porta 8080 sulla porta 80 del container.\nIl secondo container invece utilizza il comando build e il context mi indica dove trovare il Dockerfile, ovvero nella cartella sito1.\nQuindi prende una immagine personalizzata.\nInfatti viene fatta la build dell'immagine e poi gli vengono assegnati nome, volumi e porte.\nIn questo caso specifico viene inserita la pagina web: index.html durante la costruzione dell'immagine\n\nDa qui si può intuire che si potrebbero inserire n immagini con docker-compose e fare delle personalizzazioni ad hoc\nsulle immagini prima di lanciare il comando **docker compose up**\n\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgerryp92%2Fguidaadocker","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fgerryp92%2Fguidaadocker","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fgerryp92%2Fguidaadocker/lists"}