Share
Le persone che amano Docker descriverlo usando una metafora di una tecnologia piuttosto antica: il container di spedizione.
Anche se non ci pensiamo nemmeno molto o li notiamo molto ora, il container di spedizione era in realtà un pezzo di tecnologia piuttosto rivoluzionario ai suoi tempi. Indipendentemente dalla forma o dalle dimensioni dell'elemento originale, utilizzando un contenitore standardizzato, il proprietario della barca / aereo / camion / cosa-hai, è stato in grado di capire facilmente quante risorse avevano bisogno di allocare.
Docker cerca di prendere lo stesso livello di comodità e portarlo nel mondo dei server. È la naturale estensione di strumenti come Vagrant che consentono di distribuire la stessa macchina virtuale che si utilizza nello sviluppo negli ambienti di produzione. Le macchine virtuali in stile Vagrant sono fantastiche, ma sono pesanti. Richiedono molte risorse da eseguire, molte delle quali sono ridondanti: un'immagine Vagrant carica un'intera nuova copia di Linux all'interno di una esistente. Non sarebbe meglio se potessi usare la praticità e l'uniformità di Vagrant ma non dover ricaricare l'intero sistema operativo? Bene, questo è esattamente ciò che fa Docker.
In questo tutorial, ti guiderò attraverso l'intero flusso di lavoro di Docker. Per prima cosa eseguiremo la procedura per ottenere una semplice applicazione web Python che abbia una coppia di dipendenze Python e dipenda da un database Redis per la persistenza attiva e funzionante. Quindi installeremo Docker e installeremo tutti i requisiti dell'app web (dipendenze Redis, Python e Python) in un'unica immagine Docker. Quindi utilizzeremo quell'immagine e la distribuiremo su un altro server.
Implementeremo semplicemente un'app di esempio di giocattoli, ma i passaggi per implementare le tue app reali sarebbero molto simili.
Per iniziare, avrai bisogno di una scatola Linux che esegua una versione recente di Ubuntu o una macchina virtuale che esegue una versione recente di Ubuntu. Se si desidera seguire completamente il tutorial e distribuire l'app, è necessario anche un secondo computer (o una seconda macchina virtuale) da distribuire a.
Il primo passo è installare Docker stesso. Docker è in uno sviluppo molto rapido, quindi il modo più semplice per installarlo spesso cambia abbastanza rapidamente. Consulta la sezione introduttiva di Docker per verificare il livello di avanguardia.
Altrimenti, segui i passaggi sottostanti e configureremo un'installazione basata su Vagrant di Docker che funzionerà su tutti i principali sistemi operativi. Prima vai sul sito Web di Vagrant e installa Vagrant e VirtualBox più recenti per il tuo sistema operativo.
Una volta installato Vagrant, crea una nuova cartella, apri un prompt dei comandi e procedi come segue:
vagabondo init hashicorp / precise64 (... aspetta un attimo ...) vagabondo su ssh vagabondo
Vagrant si è appena occupato di creare una macchina virtuale con Ubuntu 12.04 per te e ora SSH è pronta. Ora possiamo seguire le istruzioni di installazione di Ubuntu di Docker. Controlla il sito web nel caso ci siano stati dei cambiamenti da quando è stato scritto, ma molto probabilmente, puoi incollare direttamente i seguenti comandi nel terminale:
# installa il kernel backported sudo apt-get update sudo apt-get install linux-image-generic-lts-raring linux-headers-generic-lts-raring # reboot sudo reboot
Tornerai al prompt del computer locale quando la macchina virtuale si riavvia, quindi attendi qualche istante e fallo un altro:
sergente vagabondo
... per SSH di nuovo nella tua VM. Ora che i prerequisiti di Docker sono stati installati con successo, dobbiamo andare avanti e installare Docker stesso. Incolla nel seguente comando:
curl -s https://get.docker.io/ubuntu/ | sudo sh
... che catturerà un semplice script di installazione Docker dal sito di Docker ed eseguirà. Docker dovrebbe ora essere installato con successo, quindi cominciamo a giocarci.
Una volta apt-get ha finito la sua magia, fai quanto segue:
sudo Docker esegue -i -t ubuntu / bin / bash
... per verificare e vedere che l'installazione ha avuto successo. Se funziona, Docker procederà a scaricare un'immagine di Docker di Ubuntu e, dopo un po 'di tempo, finirà con l'apparire di un prompt di root. Sentiti libero di giocare un po ', noterai che ti trovi in un ambiente completamente separato dal computer host. Probabilmente hai notato il radice e # accedi al prompt. Stai eseguendo come utente root in un nuovo ambiente virtuale. Se si rilascia un utenti comando, vedrai che gli altri tuoi utenti non sono più presenti.
Vale la pena dedicare un minuto per spiegare cosa scaricatore di porto comando che hai appena digitato e come è avvenuta questa magia.
Accentsconagua
correre ComandoL'utilità Docker sembra aver tratto molta ispirazione da idiotaL'interfaccia a riga di comando e, di conseguenza, fa uso di sottocomandi. In questo caso, abbiamo eseguito il correre sottocomando. Il correre il comando richiede due argomenti: un'immagine e un comando.
È anche intelligente, quindi se (come in questo caso) non hai quell'immagine installata, interrogherà il repository Docker centrale e ne scaricherà uno per te. Qui abbiamo detto di eseguire un ubuntu immagine e informa Docker che dovrebbe iniziare / Bin / bash dentro quell'immagine. Il -t e -io dire a Docker di assegnare un TTY ed eseguire in "modalità interattiva", in altre parole, per ottenere un prompt dei comandi. La ragione di ciò è che Docker funziona in modo leggermente diverso da altri software di virtualizzazione con cui potresti avere familiarità. Le immagini Docker non si "avviano", ma semplicemente eseguono. Stanno usando l'installazione Linux esistente, quindi l'avvio di un'immagine Docker può essere immediato. In qualche modo Docker è più vicino a Linux chroot comando piuttosto che a strumenti di virtualizzazione più tradizionali come VMWare o VirtualBox.
Esistono alcune altre differenze chiave rispetto agli strumenti di virtualizzazione standard. Facciamo un rapido esperimento e creiamo un file e stampiamo il suo contenuto:
echo Un esperimento> experiment.txt
Ora quando lo fai:
cat experiment.txt
Stamperà felicemente:
Un esperimento
Fin qui tutto bene, il nostro sciocco esperimento funziona esattamente come previsto. Uscire da Docker e tornare al prompt dei comandi del nostro computer host:
Uscita
Se si riavvia Docker con lo stesso comando utilizzato in precedenza:
sudo Docker esegue -i -t ubuntu / bin / bash
... noterai che le cose non si comportano più come ti aspetteresti. Se provi a cat il file che abbiamo creato l'ultima volta, ricevi ora un messaggio di errore:
root @ e97acdf4160c: / # cat experiment.txt cat: experiment.txt: Nessun file o directory di questo tipo
Quindi cosa sta succedendo? Le modifiche alle immagini Docker non persistono per impostazione predefinita. Per salvare le tue modifiche in un'immagine Docker, devi commettere loro, idiota stile. Questo potrebbe richiedere un po 'di tempo per abituarsi, ma è abbastanza potente perché significa che puoi anche "dirigerli" idiota stile (ne riparleremo più avanti).
Per ora, facciamo qualcosa di un po 'più utile. Installiamo pitone, Redis e alcune altre utilità che utilizzeremo per eseguire la nostra app demo a breve. Dopo, lo faremo commettere per mantenere i nostri cambiamenti. Avvia una copia di Docker sull'ultima immagine di Ubuntu:
docker -t -i ubuntu / bin / bash
L'immagine base di Ubuntu potrebbe non includere Python, quindi controlla se hai una copia digitando pitone al prompt. Se ricevi un messaggio di errore, installalo:
apt-get update apt-get install python
Fin qui tutto bene. È possibile che in seguito vorremmo creare altri progetti che facciano uso di Python, quindi andiamo avanti e salviamo queste modifiche. Apri un altro prompt dei comandi (se stai usando l'installazione di Vagrant raccomandata sopra, dovrai farlo sergente vagabondo di nuovo da un prompt separato) e procedere come segue:
docker ps
Otterrai una lista come di seguito, di tutti i contenitori Docker attualmente in esecuzione:
ID IMMAGINE COMANDO CREATO PORTE DI STATO 54a11224dae6 ubuntu: 12.04 / bin / bash 6 minuti fa Fino 6 minuti
Il numero sotto la colonna ID è importante: questo è l'ID del tuo contenitore. Questi sono unici, se esci dal tuo contenitore ed esegui di nuovo la stessa immagine, vedrai un nuovo numero lì.
Quindi ora che abbiamo installato Python, salviamo le nostre modifiche. Per fare ciò usi il commettere comando che accetta due argomenti: il contenitore di cui si desidera memorizzare le modifiche e il nome dell'immagine. La convenzione Docker deve utilizzare un ID utente seguito da a / e il nome breve dell'immagine. Quindi in questo caso, chiamiamolo tuts / python. Emettere il seguente comando per salvare l'installazione di Python, assicurandosi di sostituire l'ID per il contenitore dall'ultimo passaggio
docker commit tuts / python
Dopo alcuni secondi, ritornerà con una serie di lettere e numeri. Questo è l'ID dell'immagine che hai appena salvato. È possibile eseguire questa immagine ogni volta che lo si desidera e fare riferimento a tale numero ID o più facile da ricordare tuts / python nome che ci è stato assegnato.
Eseguiamo una copia dell'immagine che abbiamo appena realizzato:
finestra mobile run -t -i tuts / python / bin / bash
A questo punto, dovresti avere due finestre di terminale aperte che eseguono due sessioni Docker separate.
Noterai ora che se scrivi pitone in uno dei due, non riceverai più un messaggio di errore. Prova a creare un file nella seconda finestra:
touch / testfile
Ora torna alla finestra originale di Docker e prova a guardare il file:
gatto / testfile
Riceverai un messaggio di errore. Questo perché stai utilizzando una "macchina virtuale" completamente diversa in base all'immagine che hai creato con commit docker comando. I tuoi file system sono completamente separati.
Se apri ancora un altro terminale (di nuovo, dovrai correre sergente vagabondo se usi Vagrant) e fai quanto segue:
docker ps
... lo vedrai scaricatore di porto ora elenca due immagini in esecuzione, non solo una. Puoi impegnare separatamente ciascuna di queste immagini. Per continuare con idiota metafora, ora stai lavorando con due rami e sono liberi di "divergere".
Andiamo avanti e chiudiamo l'ultima finestra che abbiamo aperto. Se corri docker ps di nuovo, ora sarà elencato solo un ID. Ma cosa succede se si desidera tornare a un contenitore precedente? Se si digita:
finestra mobile ps -a
Docker elencherà anche tutti i precedenti contenitori. Non è possibile eseguire un contenitore che è stato chiuso, ma è possibile utilizzare gli ID del contenitore precedente per eseguire il commit di nuove immagini. L'esecuzione della nuova immagine ti riporterà in modo efficace allo stato del contenitore precedente.
Chiudiamo le nuove finestre che abbiamo aperto e torniamo al terminale per la prima sessione Docker che abbiamo iniziato. Una volta tornato, vai avanti e installa altri strumenti per la nostra piccola app. In questo caso, abbiamo bisogno di installare il gestore di pacchetti Python, due moduli Python per consentire a Python di agire come un server web e interagire con Redis, e il server Redis stesso.
apt-get install python-pip redis-server pip installa la bottiglia redis
Una volta finiti, commettiamo questa immagine. Da un'altra finestra del terminale, eseguire il seguente comando:
docker ps
... e prendi nota dell'ID e inseriscilo sotto il nome tuts / pyredis:
docker commit tuts / pyredis
Così ora abbiamo un'immagine Docker che contiene gli strumenti necessari per eseguire una piccola applicazione web Python con Redis che funge da back-end. Se hai progetti futuri che utilizzeranno lo stesso stack, tutto ciò che devi fare per avviarli è: finestra mobile run -t -i tuts / pyredis / bin / bash e impegni una volta aggiunto il codice sorgente.
Ok, quindi il nostro back-end è impostato. Ora per configurare l'app stessa!
Ho creato una piccola app di esempio che utilizza i moduli Redis e Python che abbiamo installato finora. L'app è abbastanza semplice, tutto ciò che fa è visualizzare un elenco delle chiavi Redis e fornisce un'interfaccia rudimentale per aggiungerle e modificarle. Prendiamo il codice sorgente sul computer host (il sergente vagabondo sessione) prima:
cd git clone https://github.com/nikvdp/tuts-docker.git pyredis
Nella home directory del tuo computer host avrai ora un pyredis cartella che contiene lo script Python che useremo. Quindi, come facciamo a copiare questa app nella nostra immagine Docker?
Bene, Docker ha una bella funzionalità che ti permette di montare una directory locale all'interno del tuo contenitore. Eseguiamo un'altra immagine Docker e montiamo la cartella:
finestra mobile run -v ~ / pyredis: / tut: rw -t -i tuts / pyredis / bin / bash
Questo è proprio come il nostro correre comandi da prima, con l'aggiunta del -v parametro.
In effetti, questo comando consente di condividere una cartella tra Docker e il computer host. Il :indica i percorsi da condividere. Nel nostro caso, stiamo condividendo il nostro pyredis cartella, situata a ~ / Pyredis sulla nostra macchina, e il montaggio a / tuts all'interno dell'immagine Docker. Il rw alla fine è per 'lettura-scrittura' e significa che le modifiche apportate all'immagine Docker verranno visualizzate anche sulla nostra macchina.
Al prompt del Docker, ora puoi fare:
cd / tuts ls
... e vedi il contenuto del ~ / Pyredis cartella sul tuo computer.
Questa condivisione è temporanea, tuttavia, se si esegue questa immagine Docker su un altro computer o si esegue nuovamente l'immagine senza -v opzione, l'immagine non avrà più accesso ad essa. Copialo in un'altra posizione all'interno dell'immagine effettiva del Docker:
cp -R / tuts / / pyredis
Poiché le modifiche ai file system di Docker sono temporanee per impostazione predefinita, salviamo l'immagine nuovamente docker ps per ottenere il nostro ID contenitore e commettere le nostre modifiche:
docker commit tuts / pyredis
Noterai che ci siamo impegnati con lo stesso nome dell'immagine che ci siamo impegnati per l'ultima volta, tuts / pyredis. Docker aggiornerà l'immagine e manterrà un registro di tutte le tue modifiche per te. Piace idiota, se si incasina, si può tornare a una buona versione semplicemente da run docker'il suo ID. Per vedere la cronologia di un'immagine, prova quanto segue:
tutor di storia docker / piredis
Vedrai qualcosa di simile a questo:
ID creato da tuts / pyredis: ultimi 17 secondi fa / bin / bash 4c3712e7443c 25 ore fa / bin / bash ubuntu: 12.10 6 mesi fa / bin / bash 27cf78414709 6 mesi fa
Questa è una storia di tutti i commit che abbiamo fatto nel processo di creazione del tuts / pyredis immagine, compresi quelli che ci siamo impegnati con nomi diversi come tuts / python. Se vuoi tornare al commit giusto prima di copiare il nostro pyredis app in / pyredis potresti provare (cambiando gli ID per abbinare ciò che mostra il tuo):
finestra mobile run -t -i 4c3712e7443c / bin / bash
... e scoprirai che non c'è / pyredis elenco.
Quindi ora abbiamo tutti i pezzi sul posto. Il prossimo passo è eseguire l'app direttamente dal suo contenitore. Dal momento che stiamo implementando un'app Web, sarà anche necessario specificare un modo per accedere all'app sul Web. Il correre il comando ti ha coperto (di nuovo). Il comando di esecuzione del Docker supporta a -p opzione che ti consente di specificare come verranno mappate le porte.
Se stai utilizzando Vagrant per eseguire Docker, dovrai configurare il port forwarding di Vagrant prima di poter eseguire test significativi. Se non stai usando Vagrant, salta questo passaggio.
Se stai utilizzando Vagrant per testarlo, devi configurare il port forwarding in modo che il browser Web della tua macchina locale possa accedere alle porte sulla VM di Vagrant, che a sua volta verrà inoltrata alla porta dell'istanza Docker. Quindi, nel nostro caso, imposteremo la porta 9000 della nostra macchina locale per inoltrarla alla 9000 di Vagrant VM, che a sua volta tuts / pyredis Porta dell'istanza Docker 8080.
Sul tuo computer locale, torna alla cartella in cui hai prima digitato init vagabondo. Troverai un file di testo chiamato semplicemente Vagrantfile. Aprilo nel tuo editor di testo preferito e cerca la seguente parte:
# Crea una mappatura delle porte inoltrate che consente l'accesso a una specifica porta # all'interno della macchina da una porta sulla macchina host. Nell'esempio seguente, # accedendo a "localhost: 8080" accederà alla porta 80 sul computer guest. # config.vm.network "forwarded_port", guest: 80, host: 8080
Decommentare la linea finale e cambiare le porte da 80 e 8080 a 8080 e 9000. Il risultato dovrebbe essere simile a questo:
# Crea una mappatura delle porte inoltrate che consente l'accesso a una specifica porta # all'interno della macchina da una porta sulla macchina host. Nell'esempio seguente, # accedendo a "localhost: 8080" accederà alla porta 80 sul computer guest. config.vm.network "forwarded_port", guest: 8080, host: 9000
Ora esegui:
ricarica vagabonda
... che farà riavviare Vagrant VM con i port forward in avanti. Una volta completato, puoi correre sergente vagabondo ancora e continua il tutorial.
Il nostro piccolo pyredis app per impostazione predefinita, apre un piccolo server Web sulla porta 8080. Il seguente comando consente di accedere alla porta 8080 tramite la porta 9000 sulla macchina host:
finestra mobile run -t -i -p 9000: 8080 tuts / pyredis / bin / bash
Avrai il prompt di root di Docker, quindi avviamo la nostra app:
redis-server 2> & 1> / dev / null e python /pyredis/app.py
Se tutto va bene, vedrai quanto segue:
Avvio del server Bottle v0.11.6 (utilizzando WSGIRefServer ()) ... Ascolto su http: // localhost: 8080 / Hit Ctrl-C per uscire.
Ciò significa che il server è in esecuzione. Sul computer locale, avviare un browser Web e puntarlo verso localhost: 9000 (se stai facendo questo tutorial su un server remoto, assicurati di avere accesso di rete alla porta 9000 e sostituisci localhost con l'indirizzo del tuo web server).
Con un po 'di fortuna, dovresti vedere la schermata principale della nostra piccola app. Vai avanti e aggiungi alcune chiavi e modifica alcuni valori. I dati dovrebbero persistere. Tuttavia, se esci dal prompt di Docker e riavvia Docker, il database sarà nuovamente vuoto, il che è qualcosa da tenere a mente se prevedi di ospitare il tuo database all'interno di un contenitore Docker.
Quindi questo è tutto perfetto per i test, ma l'obiettivo qui è essere in grado di distribuire la tua app. Non vuoi dover digitare i comandi per avviare manualmente l'app ogni volta.
La finestra mobile viene di nuovo in soccorso. Quando esegui il commit, Docker può salvare automaticamente alcune informazioni di esecuzione, quali le porte da mappare e i comandi da eseguire all'avvio dell'immagine. In questo modo, tutto ciò che devi fare è digitare scaricatore di porto e Docker si prenderà cura di tutto il resto. Vera containerizzazione.
Per il nostro script, abbiamo solo due comandi da eseguire all'avvio:
redis-server 2> & 1> / dev / null e python /pyredis/app.py
Il modo più semplice per farlo è creare un piccolo script di avvio che esegua questi due comandi. Iniziamo il nostro tuts / pyredis di nuovo e aggiungi un piccolo script di avvio (copia e incolla direttamente il seguente, nel prompt Docker):
finestra mobile run -t -i tuts / pyredis / bin / bash cat> /pyredis/launch.sh <&1 > / dev / null & #! / bin / sh python /pyredis/app.py EOF chmod + x /pyredis/launch.sh
Questo ha salvato i comandi che usiamo per lanciare il nostro server Python in un piccolo script bash chiamato launch.sh e imposta il bit eseguibile in modo che sia più semplice da eseguire.
Ora che lo script si trova nell'immagine con successo, da un altro terminale, impegnalo in modo che possa persistere (ricordati di farlo a docker ps per ottenere prima l'ID del tuo ultimo contenitore):
docker commit tuts / pyrdis
Proviamo questo. Se esci dal prompt di Docker ed esegui di nuovo il comando seguente, dovresti essere in grado di accedere all'app web di piredis a localhost: 9000, proprio come l'ultima volta.
finestra mobile run -t -i -p 8000: 8080 tuts / pyredis / bin / bash /pyredis/launch.sh
Ok, ora possiamo eseguire la nostra piccola app con un singolo comando. Ma c'è di più! Docker ti consente di salvare alcune informazioni di configurazione predefinite con i tuoi commit. In questo modo, non dobbiamo ricordarci di digitare ogni volta il nostro port mapping e di lanciare le informazioni di comando e puoi semplicemente dare un'immagine Docker a qualcun altro. Possono quindi eseguirlo con un semplice run docker e Docker si prende cura di tutto il resto.
Per configurare questo, è necessario passare alcune informazioni JSON al comando commit. Ci sono molti parametri che puoi usare, ma per ora ci limiteremo a mappare le porte e gli script di inizializzazione. Avvia il tuo editor di testo preferito e incolla quanto segue:
"cmd": ["/ bin / bash", "/pyredis/launch.sh"], "PortSpecs": ["9000: 8080"]
Questo rappresenta le informazioni che abbiamo digitato nel -p opzione così come il percorso per lo script di avvio. Un aspetto importante da notare è che per il cmd opzione, ogni luogo in cui normalmente utilizzi uno spazio viene effettivamente passato come parametro separato.
Salva lo snippet JSON in un file chiamato runconfig.json e aggiorniamo Docker per usarlo.
docker commit -run = $ (cat runconfig.json) tuts / pyredis
Ora se lo fai:
docker run tut / piredis
Vedrai bottiglia avvia e puoi accedere all'app tramite il browser.
I creatori di Docker hanno creato un registro pubblico che chiunque può spingere e tirare da immagini Docker. Ciò significa che distribuire la tua nuova app su un server remoto è facile come spingerlo nel registro centrale di Docker e quindi estrarlo da un server su cui è installato Docker.
Questo è piuttosto semplice, quindi ti riferirò alla documentazione di Docker. Se invece vuoi distribuire privatamente, leggi la sezione successiva (s).
Bene, ora abbiamo un'immagine Docker facile da usare in esecuzione sul tuo computer. Il prossimo passo è quello di distribuirlo su un server!
Questa parte è un po 'complicata. Il modello di distribuzione di Docker si basa sull'idea dei repository. Puoi spingere e tirare le immagini Docker in un repository Docker quanto vuoi e diversi server possono facilmente estrarre immagini diverse. Questo è fantastico, ma sfortunatamente è richiesto un po 'di lavoro per ospitare il tuo repository. Se stai ospitando o creando software open source, puoi semplicemente utilizzare il repository Docker pubblico direttamente per memorizzare le tue immagini. Tuttavia, se stai implementando un codice proprietario, probabilmente non vuoi farlo. Questo ti lascia due scelte:
Il primo è più semplice, ma perde molte delle funzioni più interessanti di Docker, come mantenere la cronologia delle immagini e la possibilità di memorizzare la mappatura delle porte ed eseguire la configurazione all'interno dell'immagine. Se questi sono importanti per te, passa alla sezione successiva per sapere come impostare il tuo repository Docker (privato). Se si desidera essere in grado di distribuire le immagini sui propri server, è possibile utilizzare questo metodo.
Il primo passo è quello di esportare il tuo contenitore in a .catrame archivio. Puoi farlo tramite Docker's esportare comando. Per distribuire l'app di esempio che abbiamo utilizzato in questo tutorial, dovresti fare qualcosa del genere:
esportazione finestra mobile> pyredis.tar
Docker si siederà e elaborerà per un po 'di tempo, ma in seguito avrai a pyredis.tar file che contiene l'immagine che hai creato. Puoi quindi copiare pyredis.tar al tuo server ed esegui quanto segue:
cat pyredis.tar | Importa Docker -
Docker si siederà di nuovo per un po 'e alla fine sputerà l'ID della nuova immagine che ha creato. Puoi commettere questo per un nome più memorabile in questo modo:
docker commit tuts / pyredis
La nostra app tutorial è ora distribuita ed è possibile eseguirla con lo stesso comando di esecuzione di prima:
finestra mobile run -t -i -p 8000: 8080 tuts / pyredis / bin / bash /pyredis/launch.sh
Il modo più efficace per implementare la tua app è quello di ospitare il tuo repository Docker. Ottieni Docker installato su una macchina ed esegui il seguente comando:
finestra mobile run -p 5000: 5000 samalba / docker-registry
Aspetta un po 'di tempo per scaricare i pezzi e presto dovresti vedere alcuni messaggi sull'avvio di unicorno e di operatori di avvio.
Questo significa che il tuo registro Docker è attivo e funzionante (all'interno del proprio contenitore Docker) ed è accessibile alla tua macchina locale alla porta 5000. Leggermente piegato, ma fantastico. Impostiamo prima le credenziali di accesso e quindi spingiamo l'immagine Docker creata in precedenza nel tutorial al nostro nuovo registro. In un nuovo terminale, eseguire quanto segue
docker login localhost: 5000
Vai avanti e inserisci il nome utente, la password e l'email che desideri utilizzare con il tuo repository Docker.
Al fine di spingere il tuts / pyredis app nel repository, dobbiamo prima "taggarla" con le informazioni sull'indirizzo del repository privato in questo modo:
tag tag docker / localhost pyredis: 5000 / tuts / pyredis
Questo dice a Docker di creare un nuovo "tag" di tuts / pyredis e associarlo con il pronti contro termine localhost: 5000. Puoi pensare a questo tag come al nome di questa immagine nel repository. Per coerenza, ho mantenuto i nomi uguali e l'ho etichettato localhost: 5000 / tuts / pyredis, ma questo nome potrebbe facilmente essere qualcosa di completamente diverso (come localhost: 5000 / pyredis_prod.)
Se corri immagini docker ora vedrai che c'è una nuova immagine elencata con il nome localhost: 5000 / tuts / pyredis. Il meccanismo di Docker per specificare i repository è strettamente collegato al suo meccanismo di denominazione (o tagging come lo mette Docker), quindi questo è tutto ciò di cui hai bisogno.
Per spingere l'immagine che abbiamo creato nel nostro repository, fallo e basta spinta docker e il nome completo dell'immagine con tag (incluso l'indirizzo):
docker push localhost: 5000 / tuts / pyredis
Docker si connetterà al repository in esecuzione su localhost: 5000 e inizia a spingere le tue modifiche. Vedrete un sacco di messaggi sulle varie richieste HTTP coinvolte che appaiono nell'altra finestra del terminale (quella in esecuzione samalba / finestra mobile-registro), e le informazioni sul caricamento andranno in questo. Ci vorrà un po ', quindi potresti prendere un caffè.
Un avvertimento, dal momento che il nostro repository Docker è esso stesso in esecuzione all'interno di un contenitore Docker, abbiamo bisogno di impegnare l'immagine del repository dopo aver finito di spingere. In caso contrario, poiché le modifiche al file system di Docker sono effimere, per impostazione predefinita l'immagine che abbiamo inviato al repository scomparirà non appena chiudiamo il nostro locale samalba / finestra mobile-registro Contenitore Docker.
Per fare questo, fai il solito docker ps per ottenere l'ID della corsa samalba / finestra mobile-registro contenitore e quindi impegnarlo in un nuovo contenitore. Questo non è l'ideale, se lo fai in produzione vorresti configurare i volumi Docker o usare il -v opzione dall'alto per mantenere il file del repository direttamente sul server, anziché all'interno del contenitore, ma questo non rientra nell'ambito di questo tutorial.
Ora per la parte divertente: distribuire la nostra nuova immagine Docker su un nuovo server. Poiché al momento della stesura di questo documento, i repository Docker non dispongono di alcun meccanismo di sicurezza o autenticazione, faremo il nostro lavoro su tunnel SSH sicuri. Dalla macchina virtuale in cui si imposta il tuts / pyredis lezione, SSH nel tuo server di produzione e inoltra la porta 5000 in questo modo:
ssh -R 5000: localhost: 5000 -l
Il -R bandiera a SSH significa che quando ti connetti a localhost: 5000 sul server di produzione, SSH inoltrerà la connessione alla porta 5000 sulla macchina virtuale, che a sua volta verrà inoltrata al server samalba / finestra mobile-registro container dove vive il nostro repository.
Se Docker non è installato su questo server, andare avanti e installarlo secondo le istruzioni di installazione. Una volta in esecuzione Docker, la distribuzione dell'immagine è semplice come:
docker pull localhost: 5000 / tuts / pyredis
Dal momento che abbiamo creato un tunnel tramite SSH, Docker penserà che stia tirando dal localhost del server remoto: 5000, ma questo verrà infatti trasferito al localhost della VM locale: 5000, che a sua volta viene reindirizzato a Docker. Dagli un po 'di tempo per scaricare, ma una volta fatto dovresti essere in grado di eseguire la nostra applicazione piredica esattamente nello stesso modo in cui l'abbiamo eseguita sulla VM originale, incluse le configurazioni e le porte di esecuzione salvate:
docker run tut / piredis
Ecco le basi di Docker. Con queste informazioni è ora possibile creare e gestire le immagini Docker, spingerle e trascinarle in repository pubblici e privati e distribuirle su server separati.
Que
