Løst set bliver Docker mere og mere som en universel pakkehåndtering, der fungerer på tværs af alle mulige Linux -platforme. Det tager containere og bruger dem til at løse et helt andet problem, som udviklere står over for. Problemet er, at udviklere bruger deres desktop -operativsystem (som Windows, macOS eller Linux med et ton desktop -relaterede pakker) til at skrive applikationer. Den applikation, de skriver, kører ofte på et helt andet operativsystem på en server et sted med en eller anden Linux -distribution helt anderledes end udviklerens bærbare computer.
Med Docker er tanken, at din applikation kommer pakket som et Docker -billede. Det er Docker's opgave at tage dette billede og køre det som et containeriseret program til dig. At være containeriseret betyder, at applikationen og dens afhængigheder vil køre i et isoleret miljø, der kan afvige fuldstændigt fra udviklerens bærbare computer og endda produktionsserveren. Så længe de begge understøtter Docker, kan de begge køre den samme applikation på nøjagtig samme måde.
Anatomi af et Docker -billede
Som tidligere nævnt kører en Docker -app i et aftalt miljø. Nu er spørgsmålet, hvordan skaber vi det miljø? De fleste applikationsbilleder ville importere et Docker -basisbillede og bygge deres applikation oven på det.
Ansøgninger er lavet af lag af software. Et wordpress container -image er bygget ved hjælp af et httpd container -image, som igen er bygget oven på et Ubuntu -image. Billedet, hvorpå et nyere billede er bygget, er kendt som PARENT IMAGE i Docker -terminologi. I Dockerfile (vi kommer til, hvad en Dockerfile betyder lidt senere), nævnes dette overordnede billede øverst i filen som vist nedenfor:
FRA Ubuntu: 18.04
## Resten af Dockerfilen
Denne Dockerfile, når den udføres, konverterer din applikation til et Docker -billede (en slags binær), som du derefter kan skubbe til et registreringsdatabase, hvorfra den kan trækkes for at oprette nye containere andre steder. De vil dog alle have Ubuntu: 18.04 som deres basebillede, og køre som om det er et Ubuntu -system, de kører i.
Du har muligvis bemærket dette, når du prøver at trække et nyt dockerbillede.
Dette viser, hvor mange lag der trækkes, før den faktiske applikation (som muligvis kun er et par megabyte) bringes ind.
Af denne grund vil vi gerne skabe det, der er kendt som et basisbillede. Som ikke er bygget oven på noget andet. Søgeordet scratch bruges til at angive, at dette lag ikke er bygget oven på noget andet. Ligesom:
Fra starten## Resten af Dcokerfilen
Vi vil først oprette en simpel hello-world-applikation og derefter finde ud af, hvad resten af Dockerfilen bliver. Værtsystemet er Ubuntu: 18.04 LTS, og vi bruger Docker version 17.12.1-ce til eksperimentet.
Oprettelse af en statisk binær
Docker -containere er en samling af processer, der kører isoleret fra resten af operativsystemet. Det eneste, processen er i kontakt med, er kernen. Kernel er ansvarlig for at planlægge disse processer på CPU'en, udføre hukommelsesstyring og et par andre grundlæggende bookingopgaver.
Men de fleste applikationer på højt niveau afhænger af mange systembiblioteker (f.eks glibc, musl, klibc osv ) og en masse runtime -afhængigheder som Python eller Node.js eller Java Runtime. Den binære applikation har ikke alle tilgængelige biblioteker inde i den, men når den starter udførelsen, kalder den disse biblioteker fra værtens operativsystem.
Fordi vi forsøger at skabe et billede fra bunden, ville vi ikke få disse finesser. Så vores applikation skal være en statisk fil eller en selvstændig eksekverbar fil.
Lad os starte med at oprette en mappe kaldet MyDockerImage og oprette en hello.cc -fil inde i den.
$mkdirMyDockerImage$CDMyDockerImage
$røre vedhej.cc
Åbn hello.cc ved hjælp af din foretrukne teksteditor, og tilføj følgende linjer inde i den.
#omfatteved hjælp af navneområde std;
intvigtigste(){
koste<< 'Hej! Denne meddelelse kommer fra en container n';
Vend tilbage 0;
}
Dette er et simpelt C ++ - program, der udskriver Hej! Denne besked ...
Af årsager diskuteret tidligere, vil vi kompilere dette ved hjælp af det statiske flag. Compileren, der bruges, er g ++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.
For at kompilere programmet, kør følgende kommando i det samme bibliotek:
$ g++ -o hej-statiskHej.DCDette skaber en binær eksekverbar fil hej i den samme mappe. Det er vores statiske fil. Test om det kører efter hensigten ved at nævne filnavnet i terminalen.
$./Hej 
Nu er vi klar til at containere dette enkle program.
Dockerfile
Dockerfilen består af et sæt regler, der tager dine applikationsfiler (som binære filer, kildefiler osv.) Sammen med forskellige konfigurationsparametre som filsystemlayout, udsatte porte osv. Og gør dem til en Docker -billedfil. Du kan derefter dele billedfilen med alle, der ønsker at køre det program.
Vi vil ikke grave i alle de tilgængelige muligheder for Dockerfile, i stedet vil vi skrive en meget minimalistisk Dockerfile. I den samme mappe, hvor din hallo -eksekverbare findes, skal du oprette en tom fil med navnet Dockerfile.
$røre vedDockerfileÅbn den med din foretrukne teksteditor, og skriv følgende linjer til den:
Fra startenTILFØJ hej/
CMD['/Hej']
kradse er ikke et forælderbillede. Det angiver snarere Docker, at billedet ikke er bygget oven på noget andet billede. Det er bygget fra bunden. ADD -kommando ville tage den statiske binære med navnet | _+_ | fra den aktuelle mappe og tilføje den til rodmappen i billedfilen. Når vi endelig ville køre en beholder baseret på dette billede, vil den eksekverbare hej ses i selve rodmappen på | _+_ |
Endelig har CMD -linjen en streng /Hej denne streng vil blive udført som en shell -kommando, når der oprettes en beholder ud fra dette billede, altså den binære fil, som vi tilføjede til vores beholder og udskrive den besked, vi skrev i vores app.
Lad os bygge billedet ved at påberåbe docker build kommando, der ville gå gennem Dockerfilens indhold og generere billedet. Kør følgende kommando i den samme mappe som Dockerfile og den eksekverbare binære.
$docker build-tagHej .Det - tag goddag flag indstiller billednavnet til Hej og prikken ( . ) til sidst fortæller docker build for at kigge ind i det aktuelle bibliotek efter Dockerfile og relateret indhold.
Kører Docker -beholderen
For at kontrollere, om det billede, vi lige har oprettet, vises på listen over billeder, skal du køre:
$docker -billeder 
Bemærk, hvor lille hallo -billedet er i forhold til andre billeder. Under alle omstændigheder er den klar til at blive kørt som en container,
$docker kører hej 
Det er det! Du skabte din første minimalistiske beholder fra bunden.
Andre muligheder
Selvom det altid er en mulighed at oprette billeder fra bunden, har folk ofte en tendens til at oprette billeder fra andre lette Linux -distros. For eksempel er billeder som alpine og busybox virkelig lette miljøer med mindre biblioteker som musl i stedet for glibc.
Brug dem som dit forælderbillede ved hjælp af FRA alpin: seneste ville også resultere i mindre billeder. Da basisbillederne kun er 2-5 MB i størrelse. Lad os vide, om der er noget Docker -relateret emne, som du måske vil have, at vi dækker næste gang. Du kan nå os på Twitter , Facebook eller abonnere på os via e -mail.