Aan de slag met Docker (2023)

Deze blog is de persoonlijke samenvatting van het officiële document van Docker genaamd Getting Started

Demo-applicatie

Voor de rest van deze tutorial zullen we werken met een eenvoudige takenlijstmanager die wordt uitgevoerd in Node.js. Maak je geen zorgen als je niet bekend bent met Node.js! Er is geen echte JavaScript-ervaring vereist!

Op dit moment is uw ontwikkelingsteam vrij klein en bouwt u gewoon een app om uw MVP (minimaal levensvatbaar product) te bewijzen. U wilt laten zien hoe het werkt en waartoe het in staat is, zonder na te hoeven denken over hoe het zal werken voor een groot team, meerdere ontwikkelaars, enz.

De demo-app downloaden

Ten eerste moeten we de docker-tutorial op terminal openen, voor het geval je het vergeten bent, hier is de opdracht:

$ docker run -d -p 80:80 docker/aan de slag

Je zult merken dat er een paar vlaggen worden gebruikt. Hier is wat meer informatie over hen:

• -D- voer de container uit in vrijstaande modus (op de achtergrond)
• -p 80:80- wijs poort 80 van de host toe aan poort 80 in de container
• docker/aan de slag- de te gebruiken afbeelding

download dan het zip-bestand van de tutorial om mee te beginnen.

De containerafbeelding van de app bouwen

Om de applicatie te bouwen, moeten we eenDockerfile. Een Dockerfile is gewoon een op tekst gebaseerd script met instructies dat wordt gebruikt om een ​​containerimage te maken. Als je eerder Dockerfiles hebt gemaakt, zie je mogelijk een paar fouten in de onderstaande Dockerfile. Maar maak je geen zorgen! We zullen ze overlopen.

1. Maak een bestand met de naamDockerfilein dezelfde map als het bestandpakket.jsonmet de volgende inhoud. (Controleer of het bestandDockerfileheeft geen bestandsextensie zoals.tekst)

   VANknooppunt:12- alpen# Bouwtools toevoegen om gareninstallatie te laten werken op Apple silicon / arm64-machinesLOOPapk add --no-cache python2 g++ makeWERKDIR/appKOPIËREN. .LOOPgaren installeren --productieCMD["knooppunt","src/index.js"]

2. Bouw nu de containerimage met behulp van dedokwerker gebouwdcommando.

   $CDapp/$ docker build -t aan de slag .

   Bouw een afbeelding van een Dockerfile (dokwerker gebouwd):

   $ docker build [OPTIES] PAD | URL | -

   De-Tflag markeert ons imago. Beschouw dit eenvoudig als een voor mensen leesbare naam voor de uiteindelijke afbeelding. Omdat we de afbeelding een naam hebben gegevenErmee beginnen, kunnen we naar die afbeelding verwijzen wanneer we een container uitvoeren.

   De.aan het einde van dedokwerker gebouwdopdracht vertelt dat Docker moet zoeken naar deDockerfilein de huidige map.

Een app-container starten

1. Start uw container met behulp van dehavenarbeider rennencommando en specificeer de naam van de afbeelding die we zojuist hebben gemaakt:

   $ docker run -dp 3000:3000 aan de slag

   Voer een opdracht uit in een nieuwe container (havenarbeider rennen):

   $ docker uitvoeren [OPTIES] AFBEELDING [COMMAND] [ARG...]

   Herinner de-DEn-Pvlaggen? We voeren de nieuwe container uit in de "vrijstaande" modus (op de achtergrond) en maken een mapping tussen poort 3000 van de host en poort 3000 van de container. Zonder de poorttoewijzing zouden we geen toegang hebben tot de applicatie.

2. Open na een paar seconden uw webbrowser omhttp://lokalehost:3000. Je zou onze app moeten zien!

3. Ga je gang en voeg een of twee items toe en kijk of het werkt zoals je verwacht. U kunt artikelen als voltooid markeren en artikelen verwijderen. Uw frontend slaat met succes items op in de backend! Vrij snel en gemakkelijk, hè?

Onze app updaten

1. In desrc/static/js/app.jsbestand, werk regel 56 bij om de nieuwe lege tekst te gebruiken.

   -<P naam van de klasse="tekstcentrum">Nog geen artikelen! Voeg er hierboven een toe!P>+<P naam van de klasse="tekstcentrum">Je hebt nog geen todo-items! Voeg er hierboven een toe!P>

2. Verwijder de oudeErmee beginnenafbeelding.

   1. Haal de ID van de container op met behulp van dehavenarbeider pscommando.

      $ havenarbeider ps

   2. Gebruik dedokwerker stoptcommando om de container te stoppen ( of gebruik-Fvlag aanhavenarbeider rmcommando)

      # Verwissel  met de ID van docker ps$ docker stop 

      of

      $ havenarbeiderrm-f 

   3. Zodra de container is gestopt, kunt u deze verwijderen met behulp van dehavenarbeider rmcommando.

      (Video) Docker Tutorial for Beginners [FULL COURSE in 3 Hours]

      $ havenarbeiderrm

3. Laten we onze bijgewerkte versie van de afbeelding bouwen met dezelfde opdracht die we eerder gebruikten.

   $ docker build -t aan de slag .

4. Laten we een nieuwe container starten met de bijgewerkte code.

   $ docker run -dp 3000:3000 aan de slag

Een container verwijderen met behulp van het Docker-dashboard

Als u het Docker-dashboard opent, kunt u met twee klikken een container verwijderen! Het is zeker veel gemakkelijker dan de container-ID op te zoeken en te verwijderen.

1. Terwijl het dashboard is geopend, beweegt u de muisaanwijzer over de app-container en ziet u aan de rechterkant een verzameling actieknoppen verschijnen.
2. Klik op het prullenbakpictogram om de container te verwijderen.
3. Bevestig de verwijdering en je bent klaar!

Onze app delen

Nu we een afbeelding hebben gemaakt, laten we deze delen! Om Docker-images te delen, moet u een Docker-register gebruiken. Het standaardregister is Docker Hub en hier komen alle afbeeldingen die we hebben gebruikt vandaan.

Maak een opslagplaats

Om een ​​image te pushen, moeten we eerst een repo op Docker Hub maken.

1. Ga naarDocker-huben log in als dat nodig is.
2. Klik op deMaak een opslagplaats aanknop.
3. Gebruik voor de repo-naamErmee beginnen. Zorg ervoor dat de zichtbaarheid isOpenbaar.
4. Klik op deCreërenknop!

Als u aan de rechterkant van de pagina kijkt, ziet u een sectie met de naamDocker-opdrachten. Dit geeft een voorbeeldopdracht die u moet uitvoeren om naar deze repo te pushen.

Ons imago op de proef stellen

1. Probeer in de opdrachtregel de push-opdracht uit te voeren die u op Docker Hub ziet. Merk op dat uw opdracht uw naamruimte zal gebruiken, niet "docker". (havenarbeider duwen)

Push een image of een repository naar een register

$ docker push [OPTIONS] NAAM[:TAG]

$ docker push docker/getting-startedDe push verwijst naar repository [docker.io/docker/getting-started]Een afbeelding bestaat niet lokaal met de tag: docker/getting-started

Waarom is het mislukt? De push-opdracht was op zoek naar een afbeelding met de naam docker/getting-started, maar vond er geen. Als je rentdocker-afbeelding ls, je zult er ook geen zien.

Om dit op te lossen, moeten we onze bestaande afbeelding die we hebben gebouwd "taggen" om deze een andere naam te geven.

2. Log in op de Docker Hub met de opdrachtdocker login -u UW GEBRUIKERSNAAM.

3. Gebruik dedocker-tagcommando om deErmee beginnenbeeld een nieuwe naam. Wissel zeker afJE GEBRUIKERSNAAMmet uw Docker-ID. (docker-tag)

Maak een tag TARGET_IMAGE die verwijst naar SOURCE_IMAGE

$ docker-tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]

$ docker-tag aan de slag UW-GEBRUIKERSNAAM/aan de slag

4. Probeer nu uw push-commando opnieuw. Als u de waarde van Docker Hub kopieert, kunt u hettagnaamgedeelte, omdat we geen tag aan de afbeeldingsnaam hebben toegevoegd. Als u geen tag opgeeft, gebruikt Docker een tag met de naamlaatste.

$ docker push UW-GEBRUIKERSNAAM/aan de slag

Onze afbeelding uitvoeren op een nieuwe instantie

Nu onze afbeelding is gebouwd en in een register is gepusht, laten we proberen onze app uit te voeren op een geheel nieuwe instantie die deze containerafbeelding nog nooit heeft gezien! Om dit te doen, gebruiken we Play with Docker.

1. Open uw browser omSpeel met Docker.

2. Log in met uw Docker Hub-account.

3. Nadat u bent ingelogd, klikt u op de link "+ NIEUW INSTANT TOEVOEGEN" in de linkerzijbalk. (Als je het niet ziet, maak je browser dan iets breder.) Na een paar seconden wordt er een terminalvenster in je browser geopend.

4. Start in de terminal uw pas gepushte app.

   $ docker run -dp 3000:3000 UW GEBRUIKERSNAAM/aan de slag

   Je zou moeten zien dat de afbeelding naar beneden wordt getrokken en uiteindelijk wordt opgestart!

5. Klik op de 3000-badge wanneer deze verschijnt en je zou de app met je aanpassingen moeten zien! Hoera! Als de 3000-badge niet verschijnt, kunt u op de knop "Open poort" klikken en 3000 typen.

Aanhoudende onze DB

Voor het geval je het nog niet gemerkt hebt, onze takenlijst wordt elke keer dat we de container lanceren, schoongeveegd. Waarom is dit? Laten we eens kijken hoe de container werkt.

Het bestandssysteem van de container

Wanneer een container wordt uitgevoerd, gebruikt deze de verschillende lagen van een afbeelding voor zijn bestandssysteem. Elke container krijgt ook zijn eigen "scratch space" om bestanden aan te maken/bij te werken/te verwijderen. Wijzigingen zijn niet zichtbaar in een andere container,zelfs alsze gebruiken dezelfde afbeelding.

Containervolumes

Bij het vorige experiment zagen we dat elke container elke keer dat hij start, begint met de afbeeldingsdefinitie. Hoewel containers bestanden kunnen maken, bijwerken en verwijderen, gaan die wijzigingen verloren wanneer de container wordt verwijderd en worden alle wijzigingen in die container geïsoleerd. Met volumes kunnen we dit allemaal veranderen.

Volumesbieden de mogelijkheid om specifieke bestandssysteempaden van de container terug te verbinden met de hostcomputer. Als een map in de container is aangekoppeld, worden wijzigingen in die map ook gezien op de hostcomputer. Als we diezelfde map koppelen tijdens het opnieuw opstarten van containers, zien we dezelfde bestanden.

Er zijn twee hoofdtypen volumes. We zullen uiteindelijk beide gebruiken, maar we zullen beginnen metgenoemde delen.

Onze Todo-gegevens behouden

Standaard slaat de todo-app zijn gegevens op in eenSQLite-databasebij/etc/todos/todo.db. We zullen het later hebben over het overschakelen naar een andere database-engine.

Aangezien de database een enkel bestand is, zou het, als we dat bestand op de host kunnen behouden en beschikbaar kunnen maken voor de volgende container, in staat moeten zijn om verder te gaan waar de vorige was gebleven. Door een volume aan te maken en dit te koppelen (vaak "mounten" genoemd) aan de map waarin de gegevens zijn opgeslagen, kunnen we de gegevens bewaren. Zoals onze container schrijft naar dealles.dbbestand, wordt het bewaard voor de host in het volume.

Zoals gezegd gaan we agenoemd volume. Beschouw een benoemd volume als gewoon een emmer met gegevens. Docker behoudt de fysieke locatie op de schijf en u hoeft alleen de naam van het volume te onthouden. Telkens wanneer u het volume gebruikt, zorgt Docker ervoor dat de juiste gegevens worden verstrekt.

1. Maak een volume aan met behulp van dedocker-volume makencommando. (docker-volume maken)

   $ docker volume aanmaken [OPTIONS] [VOLUME]

   $ docker volume maak todo-db

2. Stop de todo-app-container opnieuw in het Dashboard (of metdocker rm -f ), omdat het nog steeds actief is zonder het permanente volume te gebruiken.

3. Start de todo-app-container, maar voeg de-vvlag om een ​​volumekoppeling op te geven. We gebruiken het genoemde volume en koppelen het aan/etc/allemaal, waarmee alle bestanden die op het pad zijn gemaakt, worden vastgelegd.

   $ docker run -dp 3000:3000 \-v todo-db:/etc/todos \--name named-volumes \getting-started

4. Zodra de container is opgestart, opent u de app en voegt u een paar items toe aan uw takenlijst.

5. Verwijder de container voor de todo-app. Gebruik het dashboard ofhavenarbeider psom de ID te krijgen en dandocker rm -f om het te verwijderen.

6. Start een nieuwe container met dezelfde opdracht van hierboven.

7. Open de app. Je zou je items nog steeds in je lijst moeten zien!

8. Ga je gang en verwijder de container als je klaar bent met het uitchecken van je lijst.

Duiken in ons volume

Veel mensen vragen vaak "Waar is DockerEigenlijkmijn gegevens opslaan wanneer ik een volume met naam gebruik?” Als je het wilt weten, kun je dedocker volume inspecterencommando.

$ docker volume inspecteer todo-db[ {"Gemaakt bij":"2019-09-26T02:18:36Z","Bestuurder":"lokaal","Etiketten": {},"Koppelpunt":"/var/lib/docker/volumes/todo-db/_data","Naam":"all-db","Opties": {},"Domein":"lokaal"}]

DeKoppelpuntis de werkelijke locatie op de schijf waar de gegevens zijn opgeslagen. Merk op dat je op de meeste machines root-toegang nodig hebt om vanaf de host toegang te krijgen tot deze map. Maar dat is waar het is!

Bindbevestigingen gebruiken

In het vorige hoofdstuk hebben we gesproken over en gebruikt agenoemd volumeom de gegevens in onze database te bewaren. Genoemde volumes zijn geweldig als we gewoon gegevens willen opslaan, omdat we ons geen zorgen hoeven te maken over waar de gegevens worden opgeslagen.

Metbinden mounts, bepalen we het exacte koppelpunt op de host. We kunnen dit gebruiken om gegevens vast te houden, maar wordt vaak gebruikt om aanvullende gegevens in containers te plaatsen. Wanneer we aan een applicatie werken, kunnen we een bind-mount gebruiken om onze broncode in de container te mounten, zodat deze codewijzigingen kan zien, kan reageren enlaten we de veranderingen meteen zien.

Voor op knooppunten gebaseerde toepassingen,nodemonis een geweldig hulpmiddel om te kijken naar bestandswijzigingen en vervolgens de applicatie opnieuw te starten. Er zijn vergelijkbare tools in de meeste andere talen en frameworks.

Snelle vergelijkingen van volumetypes

Bindingskoppelingen en benoemde volumes zijn de twee belangrijkste typen volumes die bij de Docker-engine worden geleverd. Er zijn echter aanvullende volumestuurprogramma's beschikbaar om andere gebruiksscenario's te ondersteunen (SFTP,Ceph,NetApp,S3, en meer).

Een Dev-Mode-container starten

Om onze container uit te voeren om een ​​ontwikkelingsworkflow te ondersteunen, doen we het volgende:

• Monteer onze broncode in de container
• Installeer alle afhankelijkheden, inclusief de "dev"-afhankelijkheden
• Start nodemon om te kijken naar wijzigingen in het bestandssysteem

Dus laten we het doen!

1. Zorg ervoor dat je geen vorige hebtErmee beginnencontainers lopen.

2. Voer de volgende opdracht uit vanuit de broncodemap. We leggen achteraf uit wat er aan de hand is:

   $ docker run -dp 3000:3000 \ -w /app -v"$(pwd):/app"\ node:12-alpine \ --name Bind-Mounts \ sh -c"garen installeren && garen run dev"

   Als u PowerShell gebruikt, gebruikt u deze opdracht.

   $ docker run -dp 3000:3000 ` -w /app -v"$(pwd):/app"` node:12-alpine ` --name Bind-Mounts ` sh -c"garen installeren && garen run dev"

   Als u een Apple Silicon Mac of een ander ARM64-apparaat gebruikt, gebruikt u deze opdracht.

   $ docker run -dp 3000:3000 \ -w /app -v"$(pwd):/app"\ node:12-alpine \ --name Bind-Mounts \ sh -c"apk add --no-cache python2 g++ make && garen installeren && garen run dev"

   • -dp 3000:3000- hetzelfde als voorheen. Draai in vrijstaande (achtergrond) modus en maak een poorttoewijzing
   • -w / app- stelt de huidige werkmap van de container in waar de opdracht zal worden uitgevoerd
   • -v "$(pwd):/app"- bind mount (link) de huidige werkmap van de host naar die van de container/appmap
   • knooppunt: 12-alpine- de te gebruiken afbeelding. Merk op dat dit de basisafbeelding is voor onze app uit de Dockerfile
   • --name Bind-Mounts- hernoem de container als bind mounts
   • sh -c "garen installeren && garen uitvoeren dev"- het bevel. We starten een shell met behulp vansch(alpine heeft nietbashen) en rennengaren installereninstallerenalleafhankelijkheden en dan uitvoerengaren run dev. Als we kijken in depakket.json, we zullen zien dat deontwikkelaarhet script wordt gestartnodemon.

3. U kunt de logboeken bekijken met behulp vandocker logt -f . Je weet dat je klaar bent om te gaan als je dit ziet...

   docker logs -f $ nodemon src/index.js[nodemon] 1.19.2[nodemon] om op elk moment opnieuw op te starten, voert u `rs`[nodemon] inricht(s): *.*[nodemon] start `node src/index.js`Gebruik van sqlite-database op /etc/todos/todo.dbLuisteren op poort 3000

   Als je klaar bent met het bekijken van de logboeken, ga je naar buiten door te rakenCtrl+C.

   (Video) Getting Started with Docker

4. Laten we nu een wijziging aanbrengen in de app. In desrc/static/js/app.jsbestand, laten we de knop "Item toevoegen" veranderen in simpelweg "Toevoegen". Deze wijziging komt op regel 109 - vergeet niet om het bestand op te slaan.

   - {indienen?'Toevoegen...':'Voeg item toe'}+ {indienen ?'Toevoegen...':'Toevoegen'}

5. Ververs gewoon de pagina (of open deze) en u zou de wijziging vrijwel onmiddellijk in de browser moeten zien. Het kan enkele seconden duren voordat de Node-server opnieuw is opgestart, dus als u een foutmelding krijgt, probeer dan na een paar seconden te vernieuwen.

6. Voel je vrij om andere wijzigingen aan te brengen die je wilt aanbrengen. Als u klaar bent, stopt u de container en bouwt u uw nieuwe afbeelding met behulp vandocker build -t aan de slag ..

Het gebruik van bindbevestigingen iserggebruikelijk voor lokale ontwikkelingsopstellingen. Het voordeel is dat op de ontwikkelmachine niet alle buildtools en omgevingen hoeven te zijn geïnstalleerd. Met een enkelehavenarbeider rennenopdracht, wordt de ontwikkelomgeving opgehaald en klaar voor gebruik. We zullen het in een volgende stap over Docker Compose hebben, omdat dit onze commando's zal helpen vereenvoudigen (we krijgen al veel vlaggen).

Multi-Container-apps

Tot nu toe hebben we gewerkt met apps met één container. Maar we willen nu MySQL toevoegen aan de applicatiestack. De volgende vraag rijst vaak: “Waar wordt MySQL uitgevoerd? Installeer het in dezelfde container of voer het apart uit?” In het algemeen,elke container moet één ding doen en het goed doen.Een paar redenen:

• De kans is groot dat u API's en front-ends anders moet schalen dan databases.
• Met afzonderlijke containers kunt u afzonderlijk versie- en updateversies maken.
• Hoewel u lokaal een container voor de database kunt gebruiken, wilt u misschien een beheerde service gebruiken voor de database in productie. U wilt uw database-engine dan niet met uw app verzenden.
• Voor het uitvoeren van meerdere processen is een procesmanager vereist (de container start slechts één proces), wat het opstarten/afsluiten van de container ingewikkelder maakt.

En er zijn meer redenen. Dus we zullen onze applicatie updaten om als volgt te werken:

Containernetwerken

Onthoud dat containers standaard geïsoleerd draaien en niets weten over andere processen of containers op dezelfde machine. Dus, hoe laten we de ene container met de andere praten? Het antwoord isnetwerken. Onthoud gewoon deze regel...

Als twee containers zich op hetzelfde netwerk bevinden, kunnen ze met elkaar praten. Als ze dat niet zijn, kunnen ze dat niet.

MySQL opstarten

Er zijn twee manieren om een ​​container op een netwerk te plaatsen: 1) Wijs hem toe bij start of 2) sluit een bestaande container aan. Voorlopig maken we eerst het netwerk en koppelen we de MySQL-container bij het opstarten.

1. Creëer het netwerk.

   $ docker-netwerk maakt todo-app

2. Start een MySQL-container en koppel deze aan het netwerk. We gaan ook enkele omgevingsvariabelen definiëren die de database zal gebruiken om de database te initialiseren (zie het gedeelte "Omgevingsvariabelen" in deMySQL Docker Hub-lijst).

   $ docker run -d \ --network todo-app --network-alias mysql \ -v todo-mysql-data:/var/lib/mysql \ -e MYSQL_ROOT_PASSWORD=secret \ -e MYSQL_DATABASE=todos \ --name MySQL \mysql:5.7

   Als u PowerShell gebruikt, gebruikt u deze opdracht.

   $ docker run -d ` --network todo-app --network-alias mysql ` -v todo-mysql-data:/var/lib/mysql ` -e MYSQL_ROOT_PASSWORD=geheim ` -e MYSQL_DATABASE=todos ` --name MySQL `mysql:5.7

   Je zult ook zien dat we de--netwerkaliasvlag. We komen daar zo op terug.

Als je een zietdocker: geen overeenkomend manifestfout, komt dit omdat u probeert de container in een andere architectuur uit te voeren dan amd64, wat op dit moment de enige ondersteunde architectuur is voor de mysql-afbeelding. Voeg de vlag toe om dit op te lossen--platform linux/amd64in de vorige opdracht. Dus je nieuwe opdracht zou er zo uit moeten zien:

``` bash

3. Om te bevestigen dat de database actief is, maakt u verbinding met de database en controleert u of deze verbinding maakt.

$ havenarbeiderexec-it  mysql -p

Wanneer de wachtwoordprompt verschijnt, typt u ingeheim. Maak een lijst van de databases in de MySQL-shell en controleer of u dealledatabank.

mysql> DATABANKEN TONEN;

U zou uitvoer moeten zien die er als volgt uitziet:

+------+| Databank |+-----+| informatie_schema || mysql || performance_schema || systeem || todos |+-----+5 rijen in set (0.00 sec)

Hoera! Wij hebben onzealledatabase en het is klaar voor gebruik!

Om het sql-terminaltype te verlatenUitgangin de terminal.

Onze app uitvoeren met MySQL

De todo-app ondersteunt de instelling van enkele omgevingsvariabelen om MySQL-verbindingsinstellingen te specificeren. Zij zijn:

• MYSQL_HOST- de hostnaam voor de draaiende MySQL-server
• MYSQL_USER- de gebruikersnaam die moet worden gebruikt voor de verbinding
• MYSQL_WACHTWOORD- het wachtwoord dat moet worden gebruikt voor de verbinding
• MYSQL_DB- de database die moet worden gebruikt zodra deze is aangesloten

Met dat alles uitgelegd, laten we beginnen met onze ontwikkelklare container!

1. We specificeren elk van de bovenstaande omgevingsvariabelen en verbinden de container met ons app-netwerk.

   $ docker run -dp 3000:3000 \ -w /app -v"$(pwd):/app"\ --network todo-app \ --name MySQL-App \ -e MYSQL_HOST=mysql \ -e MYSQL_USER=root \ -e MYSQL_PASSWORD=geheim \ -e MYSQL_DB=todos \ node:12-alpine \ sh -c"garen installeren && garen run dev"

   Als u uw docker-bestand hebt bijgewerkt in het gedeelte Binding van de zelfstudie, gebruikt u de bijgewerkte opdracht:

   ```bash hl_lines="3 4 5 6 7"

   Als u MacOS gebruikt, gebruikt u deze opdracht:

   (Video) Deploy een React app met Docker

   $ docker run -dp 3000:3000 \ -w /app -v"$(pwd):/app"\ --network todo-app \ --name MySQL-App \ -e MYSQL_HOST=mysql \ -e MYSQL_USER=root \ -e MYSQL_PASSWORD=geheim \ -e MYSQL_DB=todos \ node:12-alpine \ sh -c"apk --no-cache --virtual build-dependencies voeg python2 toe make g++ && garen installeren && garen run dev"

   Als u PowerShell gebruikt, gebruikt u deze opdracht:

   $ powershell hl_lines="3 4 5 6 7"$ docker run -dp 3000:3000 ` -w /app -v"$(pwd):/app"` --network todo-app ` --name MySQL-App ` -e MYSQL_HOST=mysql ` -e MYSQL_USER=root ` -e MYSQL_PASSWORD=secret` -e MYSQL_DB=todos ` node:12-alpine` sh -c"garen installeren && garen run dev"```

2. Als we kijken naar de logboeken voor de container (docker logt ), zouden we een bericht moeten zien dat aangeeft dat het de mysql-database gebruikt.

   # Eerdere logberichten zijn weggelaten$ docker logs -f $ nodemon src/index.js[nodemon] 1.19.2[nodemon] om op elk moment opnieuw op te starten, voer `rs`[nodemon] inricht(s): *.*[nodemon] starten met `node src/index.js`Verbonden met mysql db op host mysqlLuisteren op poort 3000

3. Open de app in je browser en voeg een paar items toe aan je todolijst.

4. Maak verbinding met de mysql-database en bewijs dat de items naar de database worden geschreven. Vergeet niet, het wachtwoord isgeheim.

   $ havenarbeiderexec-it  mysql -p todos

   En voer in de mysql-shell het volgende uit:

   mysql> select * from todo_items;+-------------------------------------------------------- --+----------+|ID kaart| naam | afgerond |+-------------------------------------+-------- ------------+-----------+| c906ff08-60e6-44e6-8f49-ed56a0853e85 | Doe geweldige dingen! | 0 || 2912a79e-8486-4bc3-a4c5-460793a575ab | Geweldig zijn! | 0 |+-------------------------------------+-------- ------------+----------+

   Uiteraard ziet je tafel er anders uit omdat er jouw spullen op staan. Maar je zou ze daar moeten zien liggen!

Als je snel naar het Docker Dashboard kijkt, zie je dat er twee app-containers actief zijn. Maar er is geen echte indicatie dat ze in één app zijn gegroepeerd. We zullen zien hoe we dat binnenkort kunnen verbeteren!

Docker Compose gebruiken

Docker opstellenis een tool die is ontwikkeld om te helpen bij het definiëren en delen van toepassingen met meerdere containers. Met Compose kunnen we een YAML-bestand maken om de services te definiëren en met een enkele opdracht alles opstarten of afbreken.

Degrootvoordeel van het gebruik van Compose is dat je je applicatiestack in een bestand kunt definiëren, deze in de root van je projectrepo kunt houden (het is nu versiebeheerd) en eenvoudig iemand anders in staat kunt stellen om bij te dragen aan je project. Iemand hoeft alleen maar uw repo te klonen en de compose-app te starten. In feite zie je misschien nogal wat projecten op GitHub/GitLab die nu precies dit doen.

Docker Compose installeren

Als u Docker Desktop/Toolbox voor Windows of Mac hebt geïnstalleerd, beschikt u al over Docker Compose! Play-with-Docker-instanties hebben Docker Compose ook al geïnstalleerd. Als u op een Linux-machine werkt, moet u Docker Compose installeren met behulp vande instructies hier.

Na de installatie zou u het volgende moeten kunnen uitvoeren en versie-informatie kunnen bekijken.

$ docker-compose-versie

Ons Compose-bestand maken

Maak in de hoofdmap van het app-project een bestand met de naamdocker-compose.yml.

Onthoud dat de twee services die in het yaml-bestand zijn gedefinieerd, hetzelfde zijn als hierboven vermeld:

1. Dienst 1: app

$ docker run -d \ --network todo-app --network-alias mysql \ -v todo-mysql-data:/var/lib/mysql \ -e MYSQL_ROOT_PASSWORD=secret \ -e MYSQL_DATABASE=todos \ --name MySQL \mysql:5.7

2. Dienst 2: mysql

$ docker run -dp 3000:3000 \ -w /app -v"$(pwd):/app"\ --network todo-app \ --name MySQL-App \ -e MYSQL_HOST=mysql \ -e MYSQL_USER=root \ -e MYSQL_PASSWORD=geheim \ -e MYSQL_DB=todos \ node:12-alpine \ sh -c"apk --no-cache --virtual build-dependencies voeg python2 toe make g++ && garen installeren && garen run dev"

Onze compleetdocker-compose.ymlzou er zo uit moeten zien:

# definieer de schemaversieversie: "3.8"# definieer de lijst met services (of containers) die we willen uitvoeren als onderdeel van onze applicatieDiensten:# SERVICE 1# definieer de service-invoer en de afbeelding voor de container app: afbeelding: knooppunt: 12-alpine # migreer de opdracht commando: sch -C "apk --no-cache --virtual build-dependencies voeg python2 toe make g++ && garen installeren && garen run dev" # migreer de -p 3000:3000 poorten: - 3000:3000 # migreer zowel de werkdirectory (-w /app) als de volumetoewijzing (-v "$(pwd):/app") werkende map: /app volumes: - ./:/app # we moeten de definities van omgevingsvariabelen migreren met behulp van de omgevingssleutel. omgeving: MYSQL_HOST: mysql MYSQL_USER: wortel MYSQL_WACHTWOORD: geheim MYSQL_DB: alle# SERVICE 2# definieer de nieuwe service en noem deze mysql mysql: afbeelding: mysql:5.7 # definieer de volumetoewijzing volumes: - todo-mysql-data:/var/lib/mysql # specificeer de omgevingsvariabelen omgeving: MYSQL_ROOT_PASSWORD: geheim MYSQL_DATABASE: allevolumes: todo-mysql-gegevens:

Onze Application Stack uitvoeren

Nu we onze hebbendocker-compose.ymlbestand, we kunnen het opstarten!

1. Zorg ervoor dat er geen andere exemplaren van de app/db eerst worden uitgevoerd (havenarbeider psEnkoppelaar rm -f ).

2. Start de applicatiestack op met behulp van dedocker-componerencommando. We zullen de toevoegen-Dvlag om alles op de achtergrond uit te voeren.

   $ docker-samenstellen up -d

   Wanneer we dit uitvoeren, zouden we de uitvoer als volgt moeten zien:

   Netwerk creëren"app_standaard"met de standaard driverCreating volume"app_todo-mysql-gegevens"met standaard driverApp_app_1 maken ...klaarapp_mysql_1 maken ...klaar

   U zult merken dat het volume zowel als een netwerk is gemaakt! Standaard maakt Docker Compose automatisch een netwerk specifiek voor de applicatiestack (daarom hebben we er geen gedefinieerd in het compose-bestand).

3. Laten we de logboeken bekijken met behulp van dedocker-compose logs -fcommando. U ziet de logboeken van elk van de services die zijn verweven in een enkele stream. Dit is ongelooflijk handig als u wilt letten op timinggerelateerde problemen. De-Fvlag "volgt" het logboek, dus geeft u live uitvoer terwijl het wordt gegenereerd.

   Als je dat nog niet hebt gedaan, zie je uitvoer die er zo uitziet...

   mysql_1 | 2019-10-03T03:07:16.083639Z 0 [Opmerking] mysqld: klaarvoorverbindingen.mysql_1 | Versie:'5.7.27'stopcontact:'/var/run/mysqld/mysqld.sock'poort: 3306 MySQL Community Server (GPL) app_1 | Verbonden met mysql db op host mysqlapp_1 | Luisteren op poort 3000

   (Video) Aan de slag met SiteBuilder van Combell

   De servicenaam wordt weergegeven aan het begin van de regel (vaak gekleurd) om berichten te helpen onderscheiden. Als u de logboeken voor een specifieke service wilt bekijken, kunt u de servicenaam aan het einde van de logs-opdracht toevoegen (bijvoorbeelddocker-compose logs -f app).