Opprette et Docker -bilde fra bunnen av

Den største fordelen med Docker over enhver annen containeriseringsteknologi er at Docker er rettet mot utviklere og deres upstack -applikasjoner. Mens de riktige containeriseringsteknologiene som LXC, soner og fengsler er rettet mot et operasjonsperspektiv, eller for å si det enkelt, er disse plattformene en erstatning for virtuelle maskiner som kjører på skyen. Hvor som, docker er en erstatning for pakker og kjørbare binærfiler.

Løst sett blir Docker mer og mer som en universell pakkeansvarlig som fungerer på tvers av alle mulige Linux -plattformer. Det tar containere og bruker dem for å løse et helt annet problem som utviklerne møter. Problemet er at utviklere bruker skrivebordsoperativsystemet sitt (som Windows, MacOS eller Linux med et tonn desktop -relaterte pakker) for å skrive applikasjoner. Applikasjonen de skriver kjører ofte på et helt annet operativsystem på en server et sted med litt Linux -distribusjon helt annerledes enn for utviklerens bærbare datamaskin.

Med Docker er ideen at applikasjonen din blir pakket som et Docker -bilde. Det er Dockers jobb å ta dette bildet og kjøre det som en containerisert applikasjon for deg. Å være containere betyr at applikasjonen, og dens avhengigheter, vil kjøre i et isolert miljø som kan avvike fullstendig fra utviklerens bærbare datamaskin og til og med produksjonsserveren. Så lenge de begge støtter Docker, kan de begge kjøre den samme applikasjonen på nøyaktig samme måte.

Anatomi av et Docker -bilde

Som nevnt tidligere, vil en Docker -app kjøre på et avtalt miljø. Nå er spørsmålet hvordan vi skaper det miljøet? De fleste applikasjonsbilder ville importere et Docker -basisbilde og bygge applikasjonen sin på toppen av det.

Programmer er laget av lag med programvare. Et WordPress -containerbilde er bygget ved hjelp av et HTTPD -containerbilde som igjen er bygget på toppen av et Ubuntu -bilde. Bildet som et nyere bilde er bygget på er kjent som overordnet bilde i Docker -terminologien. I Dockerfile (vi kommer til hva en Dockerfile betyr, litt senere), er dette overordnet bilde nevnt på toppen av filen som vist nedenfor:

Fra Ubuntu: 18.04
## resten av dockerfilen

Denne dockerfilen når den utføres konverterer applikasjonen din til et Docker -bilde (et slags binær) som du deretter kan presse til et register der det kan trekkes for å lage nye containere andre steder. Imidlertid vil de alle ha Ubuntu: 18.04 som deres basisbilde, og kjører som om det er et Ubuntu -system de kjører i.

Du har kanskje lagt merke til dette når du prøver å trekke et nytt Docker -bilde.

Dette viser hvor mange lag som trekkes før den faktiske applikasjonen (som bare kan være noen få megabyte i størrelse) blir brakt inn.

Av denne grunn vil vi gjerne lage det som er kjent som et basisbilde. Som ikke er bygget oppå noe annet. Nøkkelordet "riper" brukes til å indikere at dette laget ikke er bygget oppå noe annet. Som så:

Fra bunnen av
## resten av dcokerfilen

Vi vil først lage en enkel Hello-World-applikasjon og deretter finne ut hva resten av Dockerfile kommer til å bli. Vertssystemet er Ubuntu: 18.04 LTS og vi bruker Docker versjon 17.12.1-C for eksperimentet.

Skape en statisk binær

Docker -containere er en samling prosesser som kjører isolert fra resten av operativsystemet. Det eneste prosessen er i kontakt med er kjernen. Kernel er ansvarlig for å planlegge disse prosessene på CPU, gjøre minnestyring og noen få andre grunnleggende bestillinger oppbevarer oppgaver.

Men de fleste applikasjoner på høyt nivå avhenger av mange systembiblioteker (som glibc, musl, klibc, etc) og mange runtime -avhengigheter som Python eller Node.JS eller Java Runtime. Application Binary har ikke alle bibliotekene tilgjengelig i den, men når den starter utførelse, kaller den bibliotekene fra vertsoperativsystemet.

Fordi vi prøver å lage et bilde fra bunnen av, ville vi ikke få disse receties. Så applikasjonen vår må være en statisk fil eller en frittstående kjørbar.

La oss starte med å opprette en mappe kalt myDockerimage og opprette en fil hei.CC inni den.

$ mkdir mydockerimage
$ CD MyDockerimage
$ Touch Hei.CC

Åpne hei.CC ved hjelp av favoritttekstredigereren din og legg til følgende linjer inni den.

#inkludere
ved hjelp av navneområdet STD;
int main ()
cout << "Hello! This message is coming from a container \n ";
retur 0;

Dette er et enkelt C ++ -program som skriver ut “Hei! Denne meldingen… "

Av grunner diskutert tidligere, vil vi sammenstille dette ved hjelp av det statiske flagget. Kompilatoren som brukes er G ++ (Ubuntu 7.3.0-16ubuntu3) 7.3.0.

For å kompilere programmet, kjør i samme katalog følgende kommando:

$ g ++ -o hei -statisk hei.CC

Dette oppretter en binær kjørbar fil "Hello" i samme katalog. Det er vår statiske fil. Test om det kjører som ment ved å nevne filnavnet i terminalen.

$ ./Hallo

Nå er vi klare til å container dette enkle programmet.

Dockerfile

Dockerfile består av et sett med regler som tar applikasjonsfilene dine (som binærveger, kildefiler osv.) Sammen med forskjellige konfigurasjonsparametere som filsystemoppsett, eksponerte porter osv. Og gjør dem til en Docker -bildefil. Du kan deretter dele bildefilen med alle som vil kjøre den applikasjonen.

Vi vil ikke grave oss inn i alle tilgjengelige alternativ for DockerFile, i stedet vil vi skrive en veldig minimalistisk Dockerfile. I samme katalog, der Hello -kjørbar er bosatt, oppretter du en tom fil som heter Dockerfile.

$ Touch Dockerfile

Åpne den med din favoritt tekstredigerer, og skriv følgende linjer til den:

Fra bunnen av
Legg til hei /
Cmd ["/hallo"]

ripe er ikke et foreldrebilde. Snarere indikerer det Docker at bildet ikke er bygget oppå noe annet bilde. Den er bygget fra bunnen av. Legg til kommando vil ta den statiske binære som er navngitt HalloFra gjeldende katalog og legg den til rotkatalogen til bildefilen. Når vi endelig skulle kjøre en container basert på dette bildet, vil Hello kjørbar bli sett inne i selve rotkatalogen på /Hallo.

Til slutt har CMD -linjen en streng "/Hallo" Denne strengen blir utført som en skallkommando når det opprettes en beholder fra dette bildet, og dermed den binære filen som vi la til containeren vår og skriver ut meldingen som vi skrev i appen vår.

La oss bygge bildet ved å påkalle Docker Build Kommando som ville gå gjennom Dockerfiles innhold og generere bildet. Kjør følgende kommando i samme katalog som Dockerfile og den kjørbare binære.

$ docker build -tag hei .

De -Tag Hei Flagg setter bildetavnet til Hallo og prikken ( “.) På slutten forteller Docker Build For å se på den gjeldende katalogen for DockerFile og relatert innhold.

Kjører Docker -beholderen

For å sjekke om bildet vi nettopp opprettet dukker opp i listen over bilder, kjør:

$ Docker -bilder

Legg merke til hvor lite Hello -bildet er sammenlignet med andre bilder. I alle fall er den klar til å bli kjørt som en container,

$ Docker Run Hello

Det er det! Du opprettet din første minimalistiske beholder fra bunnen av.

Andre muligheter

Selv om det alltid er et alternativ å lage bilder fra bunnen av, har folk ofte en tendens til å lage bilder fra andre lette Linux -distros. For eksempel er bilder som Alpine og BusyBox virkelig lette miljøer med mindre biblioteker som Musl i stedet for glibc.

Bruker dem som ditt foreldrebilde ved å bruke “Fra Alpine: siste” ville resultere i mindre bilder også. Siden basebildene bare er 2-5 MB i størrelse. Gi oss beskjed om det er noe Docker -relatert emne som du kanskje vil at vi skal dekke neste gang. Du kan nå oss på Twitter, Facebook eller abonnere på oss via e -post.