Share
Les gens qui fabriquent Docker aiment décrire cela en utilisant une métaphore pour une technologie assez ancienne: le conteneur.
Même si nous n'y pensons même pas et ne les remarquons pas beaucoup, le conteneur d'expédition était en fait une technologie assez révolutionnaire à son époque. Peu importe la forme ou la taille de l'article d'origine, le propriétaire du bateau, de l'avion, du camion ou de ce que vous avez a pu déterminer facilement le nombre de ressources à affecter en utilisant un conteneur standard..
Docker essaie de prendre ce même niveau de commodité et de l’apporter au monde des serveurs. C'est l'extension naturelle d'outils tels que Vagrant qui vous permet de déployer la même machine virtuelle que vous utilisez dans le développement dans des environnements de production. Les machines virtuelles de style vagabond sont excellentes, mais elles sont lourdes. Elles nécessitent beaucoup de ressources, dont une grande partie est redondante: une image vagabonde charge une nouvelle copie de Linux dans une copie existante. Ne serait-il pas préférable d'utiliser la commodité et l'uniformité de Vagrant sans avoir à recharger tout le système d'exploitation? Eh bien, c'est exactement ce que fait Docker.
Dans ce tutoriel, je vais vous expliquer le flux de travail complet de Docker. Nous allons d’abord suivre les étapes pour obtenir une application Web Python simple comportant quelques dépendances Python et reposant sur une base de données Redis pour la persistance. Nous installerons ensuite Docker et toutes les exigences de l’application Web (dépendances de Redis, Python et Python) dans une seule image Docker. Nous allons ensuite utiliser cette image et la déployer sur un autre serveur.
Nous allons simplement déployer un exemple d'application de jouet, mais les étapes pour déployer vos propres applications réelles seraient très similaires.
Pour commencer, vous avez besoin d'une machine Linux exécutant une version récente d'Ubuntu ou d'une machine virtuelle exécutant une version récente d'Ubuntu. Si vous souhaitez suivre pleinement le didacticiel et déployer l'application, vous aurez également besoin d'une deuxième machine (ou d'une deuxième machine virtuelle) à déployer sur.
La première étape consiste à installer Docker lui-même. Docker est en cours de développement, donc la méthode d'installation la plus simple change souvent assez rapidement. Consultez la section de démarrage de Docker si vous souhaitez connaître le tranchant.
Sinon, suivez les étapes ci-dessous et nous allons configurer une installation de Docker basée sur une machine virtuelle Vagrant qui fonctionnera sous l’un des systèmes d’exploitation principaux. Rendez-vous d'abord sur le site Web de Vagrant et installez les dernières versions de Vagrant et VirtualBox pour votre système d'exploitation..
Une fois que Vagrant est installé, créez un nouveau dossier, ouvrez une invite de commande et procédez comme suit:
vagrant init hashicorp / precise64 (... attendez un peu ...) vagabond up vagrant ssh
Vagrant s'est juste occupé de créer une machine virtuelle exécutant Ubuntu 12.04 pour vous et vous êtes maintenant SSH dans son invite. Nous pouvons maintenant suivre les instructions d'installation de Docker Ubuntu. Consultez le site Web au cas où il y aurait eu des changements depuis sa rédaction, mais vous pouvez très probablement coller directement les commandes suivantes dans le terminal:
# installer le noyau sauvegardé sudo apt-get update sudo apt-get installer linux-image-generic-lts-raring linux-headers-generic-lts-raring # reboot sudo reboot
Vous serez redirigé vers l'invite de votre ordinateur local au redémarrage de la machine virtuelle. Attendez quelques instants et procédez de nouveau:
ssh vagabond
… À SSH dans votre VM. Maintenant que les conditions préalables de Docker ont été installées avec succès, nous devons installer Docker lui-même. Collez dans la commande suivante:
curl -s https://get.docker.io/ubuntu/ | sudo sh
… Qui va récupérer un simple script d'installation Docker sur le site de Docker et l'exécuter. Docker devrait maintenant être installé avec succès, alors commençons à jouer avec.
Une fois que apt-get a terminé sa magie, procédez comme suit:
sudo Docker lance -i -t ubuntu / bin / bash
… Pour vérifier que l'installation a réussi. Si cela fonctionne, Docker procédera au téléchargement d'une image Ubuntu Docker et, au bout d'un certain temps, vous obtiendrez ce qui ressemble à une invite racine. N'hésitez pas à jouer un peu, vous remarquerez que vous vous trouvez dans un environnement complètement séparé de votre ordinateur hôte. Vous avez probablement remarqué le racine et # connectez-vous à l'invite. Vous utilisez l'utilisateur root dans un nouvel environnement virtuel. Si vous émettez un utilisateurs commande, vous verrez que vos autres utilisateurs ne sont plus présents.
Il vaut la peine de prendre une minute pour expliquer ce que le docker commande que vous venez de taper fait et comment cette magie s'est produite.
Accentsconagua
courir CommanderL’utilitaire Docker semble s’être beaucoup inspiré de gitL'interface de ligne de commande de et, par conséquent, il utilise des sous-commandes. Dans ce cas, nous avons couru le courir sous-commande. le courir commande nécessite deux arguments: une image et une commande.
C'est aussi intelligent, donc si (comme dans ce cas) vous n'avez pas installé cette image, elle interrogera le référentiel Docker central et en téléchargera une pour vous. Ici nous lui avons dit de lancer un Ubuntu image et informé Docker qu'il devrait commencer / bin / bash à l'intérieur de cette image. le -t et -je Indiquez à Docker d’affecter un téléscripteur et de le lancer en "mode interactif", autrement dit, pour vous obtenir une invite de commande. La raison en est que Docker fonctionne un peu différemment des autres logiciels de virtualisation que vous connaissez peut-être. Les images de Docker ne "démarrent" pas, elles sont simplement exécutées. Ils utilisent l’installation Linux existante, le démarrage d’une image Docker peut donc être immédiat. À certains égards, Docker est plus proche de Linux chroot commande que des outils de virtualisation plus traditionnels tels que VMWare ou VirtualBox.
Il existe d'autres différences importantes par rapport aux outils de virtualisation standard. Faisons un test rapide pour créer un fichier et en imprimer le contenu:
echo Une expérience> experiment.txt
Maintenant quand tu fais:
chat experience.txt
Il imprimera volontiers:
Une expérience
Jusqu'ici tout va bien, notre expérience idiote fonctionne exactement comme prévu. Quittons Docker et revenons à l'invite de commande de notre ordinateur hôte:
sortie
Si vous redémarrez Docker avec la même commande que vous avez utilisée auparavant:
sudo Docker lance -i -t ubuntu / bin / bash
… Vous remarquerez que les choses ne se comportent plus comme prévu. Si vous essayez de chatter le fichier que nous avons créé la dernière fois, vous obtenez maintenant un message d'erreur:
root @ e97acdf4160c: / # cat experiment.txt cat: experiment.txt: aucun fichier ou répertoire de ce type
Alors que se passe-t-il? Les modifications apportées aux images Docker ne persistent pas par défaut. Pour enregistrer vos modifications dans une image Docker, vous devez commettre leur, git style. Cela peut prendre un peu de temps pour s’y habituer, mais c’est assez puissant parce que cela signifie que vous pouvez aussi les "ramifier" git style (plus sur cela plus tard).
Pour l'instant, faisons quelque chose d'un peu plus utile. Installons python, redis et quelques autres utilitaires que nous utiliserons pour exécuter notre application de démonstration sous peu. Ensuite, nous allons commettre persister nos changements. Créez une copie de Docker sur la dernière image Ubuntu:
docker -t -i ubuntu / bin / bash
L’image de base d’Ubuntu peut ne pas inclure Python, alors vérifiez si vous en avez une copie en tapant python à l'invite. Si vous recevez un message d'erreur, installons-le:
apt-get update apt-get install python
Jusqu'ici tout va bien. Il est possible que plus tard, nous souhaitons créer d'autres projets utilisant Python. Continuons donc en enregistrant ces modifications. Ouvrez une autre invite de commande (si vous utilisez l’installation Vagrant recommandée ci-dessus, vous devrez ssh vagabond à nouveau depuis une invite séparée) et procédez comme suit:
docker ps
Vous obtiendrez une liste comme ci-dessous de tous les conteneurs Docker en cours d'exécution:
ID IMAGE COMMAND CRÉATION DE PORTS DE STATUT 54a11224dae6 ubuntu: 12.04 / bin / bash il ya 6 minutes en haut Up en 6 minutes
Le numéro sous la colonne ID est important: il s'agit de l'ID de votre conteneur. Celles-ci sont uniques. Si vous quittez votre conteneur et exécutez à nouveau la même image, vous verrez un nouveau numéro à cet endroit..
Alors maintenant que Python est installé, sauvegardons nos modifications. Pour ce faire, vous utilisez le commettre commande qui prend deux arguments: le conteneur dont vous souhaitez stocker les modifications et le nom de l'image. La convention de Docker consiste à utiliser un ID utilisateur suivi d'un / et le nom abrégé de l'image. Donc, dans ce cas, appelons cela tuts / python. Exécutez la commande suivante pour enregistrer votre installation Python, en veillant à substituer l'ID de votre conteneur à partir de la dernière étape.
docker commit tuts / python
Après quelques secondes, il retournera avec une série de lettres et de chiffres. Ceci est l'ID de l'image que vous venez de sauvegarder. Vous pouvez exécuter cette image à tout moment et y faire référence soit par son numéro d'identification, soit par la méthode la plus simple à mémoriser. tuts / python nom que nous lui avons attribué.
Lançons une copie de l'image que nous venons de faire:
docker run -t -i tuts / python / bin / bash
À ce stade, vous devez ouvrir deux fenêtres de terminal exécutant deux sessions Docker distinctes..
Vous remarquerez maintenant que si vous tapez python dans les deux cas, vous ne recevrez plus de message d'erreur. Essayez de créer un fichier dans la deuxième fenêtre:
touch / testfile
Revenez maintenant à votre fenêtre Docker d'origine et essayez de regarder le fichier:
chat / testfile
Vous recevrez un message d'erreur. C’est parce que vous utilisez une "machine virtuelle" totalement différente, basée sur l’image créée avec le docker commit commander. Vos systèmes de fichiers sont entièrement séparés.
Si vous ouvrez encore un autre terminal (encore une fois, vous devrez exécuter ssh vagabond si vous utilisez Vagrant) et procédez comme suit:
docker ps
… Tu verras ça docker répertorie maintenant deux images en cours d'exécution, pas une seule. Vous pouvez vous engager séparément pour chacune de ces images. Pour continuer avec git métaphore, vous travaillez maintenant avec deux branches et elles sont libres de "diverger".
Allons-y et fermons la dernière fenêtre que nous avons ouverte. Si vous courez docker ps encore une fois, il n’y aura plus qu’un seul identifiant. Mais que faire si vous voulez revenir à un conteneur précédent? Si vous tapez:
docker ps -a
Docker listera également tous les conteneurs précédents. Vous ne pouvez pas exécuter un conteneur qui a été fermé, mais vous pouvez utiliser les ID du conteneur précédent pour valider de nouvelles images. L'exécution de la nouvelle image vous ramènera à l'état de votre précédent conteneur..
Fermons les nouvelles fenêtres que nous avons ouvertes et revenons au terminal pour la première session Docker que nous avons démarrée. Une fois de retour, installez d’autres outils pour notre petite application. Dans ce cas, nous devons installer le gestionnaire de paquets Python, deux modules Python, pour laisser Python agir en tant que serveur Web et interagir avec redis, et le serveur Redis lui-même.
apt-get installer le python-pip Redis-serveur pip installer la bouteille Redis
Une fois ces opérations terminées, engageons cette image. Depuis une autre fenêtre de terminal, exécutez la commande suivante:
docker ps
… Et notez l'ID et engagez-le sous le nom tuts / pyredis:
docker commit tuts / pyredis
Nous avons donc maintenant une image Docker qui contient les outils nécessaires pour exécuter une petite application Web Python avec Redis servant d’arrière-plan. Si vous avez des projets futurs qui utiliseront la même pile, il vous suffit de les lancer: docker run -t -i tuts / pyredis / bin / bash et validez une fois que vous avez ajouté votre code source.
Ok, donc notre backend est mis en place. Maintenant, pour configurer l'application elle-même!
J'ai créé un petit exemple d'application utilisant les modules Redis et Python que nous avons installés jusqu'à présent. L'application est assez simple, elle affiche une liste des touches Redis et fournit une interface rudimentaire pour les ajouter et les éditer. Récupérons le code source sur votre machine hôte (le ssh vagabond session) premier:
cd git clone https://github.com/nikvdp/tuts-docker.git pyredis
Dans le répertoire personnel de votre machine hôte, vous aurez maintenant un pyredis dossier qui contient le script Python que nous allons utiliser. Alors, comment allons-nous copier cette application dans notre image Docker?
Eh bien, Docker a une fonctionnalité intéressante qui vous permet de monter un répertoire local dans votre conteneur. Lançons une autre image Docker et montons le dossier:
docker run -v ~ / pyredis: / tuts: rw -t -i tuts / pyredis / bin / bash
C'est comme notre courir commandes d'avant, avec l'ajout de la -v paramètre.
En effet, cette commande vous permet de partager un dossier entre Docker et votre ordinateur hôte. le :'indique les chemins à partager. Dans notre cas, nous partageons notre pyredis dossier, situé à ~ / pyredis sur notre machine, et le monter à / tuts à l'intérieur de l'image de Docker. le rw à la fin est pour 'lecture-écriture' et signifie que les modifications apportées sur l'image Docker seront également visibles sur notre machine.
À l'invite de votre Docker, vous pouvez maintenant faire:
cd / tuts ls
… Et voir le contenu de la ~ / pyredis dossier sur votre machine.
Toutefois, ce partage est temporaire si vous exécutez cette image Docker sur un autre ordinateur ou réexécutez cette image sans le -v En option, l’image n’y aura plus accès. Copions-le dans un autre emplacement de l’image réelle de Docker:
cp -R / tuts / / pyredis
Les modifications apportées aux systèmes de fichiers Docker étant éphémères par défaut, sauvegardons cela dans l'image en effectuant de nouveau docker ps pour obtenir notre ID de conteneur et valider nos modifications:
docker commit tuts / pyredis
Vous remarquerez ici que nous nous sommes engagés à utiliser le même nom d'image que celui auquel nous nous sommes engagés la dernière fois., tuts / pyredis. Docker mettra à jour l'image et gardera un journal de toutes vos modifications pour vous. Comme git, si vous vous trompez, vous pouvez revenir à une bonne version simplement en docker runson identité. Pour voir l'historique d'une image, procédez comme suit:
histoire docker tuts / pyredis
Vous verrez quelque chose comme ça:
ID CRÉÉ CRÉÉ PAR tuts / pyredis: 17 dernières secondes / bin / bash 4c3712e7443c il y a 25 heures / bin / bash durée: 12.10 il y a 6 mois / bin / bash 27cf78414709 il y a 6 mois
C’est l’histoire de tous les engagements que nous avons pris dans le processus de création du tuts / pyredis image, y compris ceux que nous avons engagés à différents noms comme tuts / python. Si vous voulez revenir au commit juste avant de copier notre pyredis app dans / pyredis vous pouvez essayer (changer les identifiants pour qu'ils correspondent à ceux que vous voyez):
docker run -t -i 4c3712e7443c / bin / bash
… Et vous constaterez qu'il n'y a pas / pyredis annuaire.
Alors maintenant, nous avons toutes les pièces en place. L'étape suivante consiste à exécuter l'application à partir de son conteneur. Étant donné que nous déployons une application Web, nous devrons également spécifier un moyen d'accéder à l'application via le Web. le courir la commande vous a couvert (encore). La commande d'exécution de Docker prend en charge une -p option qui vous permet de spécifier comment les ports seront mappés.
Si vous utilisez Vagrant pour exécuter Docker, vous devez configurer le transfert de port de Vagrant avant de pouvoir effectuer des tests significatifs. Si vous n'utilisez pas Vagrant, passez simplement cette étape.
Si vous utilisez Vagrant afin de tester cela, vous devez configurer le transfert de port de sorte que le navigateur Web de votre ordinateur local puisse accéder aux ports de la machine virtuelle Vagrant, qui les transfère ensuite au port de l'instance Docker. Donc, dans notre cas, nous allons configurer le port 9000 de notre machine locale pour qu’il soit transféré à notre ordinateur 9000 Vagrant VM, qui les transmettra à notre tuts / pyredis Port 8080 de l'instance Docker.
Sur votre ordinateur local, retournez au dossier dans lequel vous avez tapé init vagabond. Vous y trouverez un fichier texte appelé simplement Vagrantfile. Ouvrez-le dans votre éditeur de texte préféré et cherchez la partie suivante:
# Créez un mappage de port transféré qui permet d'accéder à un numéro de port spécifique de la machine à partir d'un port de la machine hôte. Dans l'exemple ci-dessous, # accéder à "localhost: 8080" accédera au port 80 sur la machine invitée. # config.vm.network "forwarded_port", invité: 80, hôte: 8080
Décommentez la dernière ligne et changez les ports de 80 et 8080 à 8080 et 9000. Le résultat devrait ressembler à ceci:
# Créez un mappage de port transféré qui permet d'accéder à un numéro de port spécifique de la machine à partir d'un port de la machine hôte. Dans l'exemple ci-dessous, # accéder à "localhost: 8080" accédera au port 80 sur la machine invitée. config.vm.network "forwarded_port", invité: 8080, hôte: 9000
Maintenant, lancez:
rechargement vagabond
… Ce qui entraînera le redémarrage de la machine virtuelle Vagrant avec le port correct en avant. Une fois cette opération terminée, vous pouvez exécuter ssh vagabond encore et continuez le tutoriel.
Notre petit pyredis Par défaut, app ouvre un petit serveur Web sur le port 8080. La commande suivante vous permettra d'accéder au port 8080 via le port 9000 sur votre ordinateur hôte:
docker run -t -i -p 9000: 8080 tuts / pyredis / bin / bash
Vous obtiendrez une invite de la racine Docker, alors démarrons notre application:
serveur redis 2> & 1> / dev / null & python /pyredis/app.py
Si tout va bien, vous verrez ce qui suit:
Mise en bouteille du serveur v0.11.6 (à l'aide de WSGIRefServer ())… Écoute sur http: // localhost: 8080 / Appuyez sur Ctrl-C pour quitter.
Cela signifie que le serveur est en cours d'exécution. Sur votre ordinateur local, lancez un navigateur Web et pointez-le sur localhost: 9000 (Si vous suivez ce didacticiel sur un serveur distant, assurez-vous de disposer d'un accès réseau au port 9000 et remplacez localhost avec l'adresse de votre serveur web).
Avec un peu de chance, vous devriez voir l'écran principal de notre petite application. Allez-y, ajoutez quelques clés et modifiez certaines valeurs. Les données devraient persister. Cependant, si vous quittez l'invite Docker et redémarrez Docker, la base de données sera à nouveau vide, ce qui est à garder à l'esprit si vous envisagez d'héberger votre base de données dans un conteneur Docker..
Tout cela est donc formidable pour les tests, mais l'objectif ici est de pouvoir déployer votre application. Vous ne voulez pas avoir à taper les commandes pour démarrer votre application manuellement à chaque fois.
Docker vient à nouveau à la rescousse. Lorsque vous validez, Docker peut enregistrer automatiquement certaines informations d'exécution, telles que les ports à mapper et les commandes à exécuter au démarrage de l'image. De cette façon, tout ce que vous avez à faire est de taper docker et Docker s'occupera du reste. Véritable conteneurisation.
Pour notre script, nous n'avons que deux commandes à exécuter au démarrage:
serveur redis 2> & 1> / dev / null & python /pyredis/app.py
Pour ce faire, le plus simple consiste à créer un petit script de lancement exécutant ces deux commandes. Commençons notre tuts / pyredis à nouveau et ajoutez un petit script de lancement (copiez et collez directement le texte ci-dessous dans l'invite de Docker):
docker 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
Cela a sauvegardé les commandes que nous utilisons pour lancer notre serveur Python dans un petit script bash appelé launch.sh et définit le bit exécutable afin qu'il soit plus facile d'exécuter.
Maintenant que le script est correctement dans l’image, depuis un autre terminal, validez-le pour qu’il persiste (n'oubliez pas de faire une docker ps pour obtenir en premier votre identifiant de conteneur):
docker commit tuts / pyrdis
Testons cela. Si vous quittez votre invite Docker et que vous l'exécutez à nouveau avec la commande suivante, vous devriez pouvoir accéder à l'application Web pyredis à l'adresse localhost: 9000, comme la dernière fois.
docker run -t -i -p 8000: 8080 tuts / pyredis / bin / bash /pyredis/launch.sh
Ok, nous pouvons maintenant exécuter notre petite application avec une seule commande. Mais il y a plus! Docker vous permet de sauvegarder certaines informations de configuration par défaut avec vos commits. De cette façon, nous n’avons pas besoin de nous rappeler de taper notre mappage de ports et de lancer les informations de commande à chaque fois et vous pouvez simplement donner une image Docker à quelqu'un d’autre. Ils peuvent ensuite le lancer avec un simple docker run et Docker s'occupe du reste.
Pour configurer cela, vous devez transmettre des informations JSON à la commande commit. Il y a beaucoup de paramètres que vous pouvez utiliser, mais pour l'instant, nous allons simplement nous occuper de la cartographie des ports et des scripts d'initialisation. Lancez votre éditeur de texte préféré et collez ce qui suit:
"cmd": ["/ bin / bash", "/pyredis/launch.sh"], "PortSpecs": ["9000: 8080"]
Ceci représente les informations que nous avons tapées dans -p option ainsi que le chemin d'accès au script de lancement. Un point important à noter est que pour le cmd option, chaque endroit où vous utiliseriez normalement un espace est en fait passé en tant que paramètre séparé.
Enregistrez cet extrait de code JSON dans un fichier appelé runconfig.json et mettons à jour Docker pour l'utiliser.
docker commit -run = $ (cat runconfig.json) tuts / pyredis
Maintenant si vous le faites:
docker run tuts / pyredis
Tu verras bouteille démarrer et vous pouvez accéder à l'application via le navigateur.
Les créateurs de Docker ont créé un registre public sur lequel tout le monde peut copier et extraire des images. Cela signifie que déployer votre nouvelle application sur un serveur distant est aussi simple que de la placer dans le registre central de Docker, puis de l'extraire d'un serveur sur lequel Docker est installé..
C'est assez simple, je vous renvoie donc à la propre documentation de Docker. Si vous souhaitez plutôt déployer en privé, lisez la ou les sections suivantes..
Génial, nous avons maintenant une image Docker facile à utiliser qui s'exécute sur votre machine. La prochaine étape consiste à le déployer sur un serveur!
Cette partie est un peu compliquée. Le modèle de distribution de Docker est basé sur l'idée de référentiels. Vous pouvez pousser et extraire vos images Docker vers un référentiel Docker autant de fois que vous le souhaitez et différents serveurs peuvent tous en extraire différentes images. C'est formidable, mais malheureusement, un peu de travail est nécessaire pour héberger votre propre référentiel. Si vous hébergez ou créez un logiciel open source, vous pouvez simplement utiliser le référentiel public Docker directement pour stocker vos images. Cependant, si vous déployez du code propriétaire, vous ne voudrez probablement pas faire cela. Cela vous laisse deux choix:
Le premier est plus simple, mais perd de nombreuses fonctionnalités de refroidissement de Docker, telles que la conservation de l'historique de vos images, la possibilité de stocker le mappage de port et la configuration dans l'image. Si cela vous importe, passez à la section suivante pour apprendre à configurer votre propre référentiel (privé) Docker. Si vous souhaitez simplement pouvoir déployer vos images sur vos serveurs, vous pouvez utiliser cette méthode..
La première étape consiste à exporter votre conteneur dans un .le goudron archiver. Vous pouvez le faire via Docker's exportation commander. Pour déployer l'exemple d'application que nous avons utilisé dans ce didacticiel, procédez comme suit:
docker exportation> pyredis.tar
Docker va s'asseoir et traiter pendant un certain temps, mais après vous aurez un pyredis.tar fichier qui contient l'image que vous avez créée. Vous pouvez ensuite copier pyredis.tar sur votre serveur et exécutez ce qui suit:
chat pyredis.tar | Import Docker -
Docker va de nouveau s'asseoir un moment et finalement cracher l'ID de la nouvelle image qu'il a créée. Vous pouvez commettre ceci à un nom plus mémorable en faisant ceci:
docker commit tuts / pyredis
Notre application de tutoriel est maintenant déployée et vous pouvez l'exécuter avec la même commande d'exécution que précédemment:
docker run -t -i -p 8000: 8080 tuts / pyredis / bin / bash /pyredis/launch.sh
La meilleure façon de déployer votre application consiste à héberger votre propre référentiel Docker. Obtenez Docker installé sur une machine et exécutez la commande suivante:
docker run -p 5000: 5000 samalba / docker-registry
Attendez un peu qu'il télécharge les morceaux et vous devriez bientôt voir quelques messages sur le démarrage d'une licorne et le démarrage de travailleurs.
Cela signifie que votre registre Docker est opérationnel (à l'intérieur de son propre conteneur Docker) et est accessible à votre ordinateur local au port 5000. Légèrement déroutant, mais génial. Définissons d'abord nos informations de connexion, puis transmettons l'image Docker créée précédemment dans le didacticiel à notre nouveau registre. Dans un nouveau terminal, lancez le programme suivant
connexion docker localhost: 5000
Allez-y et entrez le nom d'utilisateur, mot de passe et email que vous souhaitez utiliser avec votre référentiel Docker.
Afin de pousser le tuts / pyredis app dans le repo, nous devons d’abord le "taguer" avec les informations d’adresse du référentiel privé comme ceci:
étiquette de docker tuts / pyredis localhost: 5000 / tuts / pyredis
Ceci dit à Docker de créer un nouveau "tag" de tuts / pyredis et l'associer avec le repo en cours d'exécution à localhost: 5000. Vous pouvez considérer cette balise comme le nom de cette image dans le référentiel. Par souci de cohérence, j'ai gardé les mêmes noms et les ai étiquetés localhost: 5000 / tuts / pyredis, mais ce nom pourrait facilement être quelque chose de complètement différent (comme localhost: 5000 / pyredis_prod.)
Si vous courez images de docker maintenant, vous verrez qu'il y a une nouvelle image listée avec le nom localhost: 5000 / tuts / pyredis. Le mécanisme de Docker pour spécifier les référentiels est étroitement lié à son mécanisme de dénomination (ou de balisage comme Docker le dit), c'est donc tout ce dont vous avez besoin..
Pour envoyer l'image que nous avons créée dans notre référentiel, il suffit de faire docker push et le nom complet de l'image balisée (y compris l'adresse):
menu fixe push localhost: 5000 / tuts / pyredis
Docker se connectera à votre référentiel sous localhost: 5000 et commencez à pousser vos modifications. Vous verrez beaucoup de messages sur les différentes requêtes HTTP impliquées s'afficher dans la fenêtre de l'autre terminal (celle en cours d'exécution). samalba / docker-registry), et les informations sur le téléchargement passeront par celui-ci. Cela prendra un certain temps, alors vous voudrez peut-être prendre un café.
Une mise en garde, étant donné que notre référentiel Docker s'exécute lui-même à l'intérieur d'un conteneur Docker, nous devons valider l'image du référentiel une fois que nous avons fini de pousser. Dans le cas contraire, les modifications du système de fichiers Docker étant éphémères, l’image que nous avons transmise au référentiel disparaîtra par défaut dès que nous fermerons notre système local. samalba / docker-registry Conteneur Docker.
Pour ce faire, faites comme d'habitude docker ps pour obtenir l'ID de la course samalba / docker-registry conteneur et ensuite le valider dans un nouveau conteneur. Ce n’est pas idéal. Si vous faites cela en production, vous voudriez configurer les volumes Docker ou utiliser le -v Option ci-dessus pour conserver le fichier du référentiel directement sur le serveur, plutôt que dans le conteneur, mais cela sort du cadre de ce tutoriel..
Passons maintenant à la partie amusante: déployer notre nouvelle image Docker sur un nouveau serveur. Au moment d'écrire ces lignes, les référentiels Docker ne disposent d'aucun mécanisme de sécurité ou d'authentification, nous ferons notre travail sur des tunnels SSH sécurisés. À partir de la machine virtuelle sur laquelle vous avez configuré le tuts / pyredis Didacticiel, ssh dans votre serveur de production et transmettez le port 5000
