Forstå dockerfilen

Du vil være enig med meg i at påvirkningen Docker har på teknologiens verden er massiv. Det sparer programvareutviklere og systemadministratorer mye hodepine.

I denne artikkelen vil du lære om en veldig avgjørende del av hele Docker -oppsettet, Dockerfile. Dockerfile bruker en enkel struktur. Selv om denne enkelheten er en god ting, gir den rom for enkeltpersoner å bare hacke kommandoer sammen, uten å forstå virkningen fullt ut.

På slutten av denne artikkelen har du en bedre forståelse av Dockerfile. Så du kan skrive dockerfiles som du forstår.

Inne i Dockerfile

Dockerfile er i utgangspunktet en tekstfil. Men i motsetning til vanlige tekstfiler, vil du se at den ikke har en .tekst filutvidelse. Dockerfile er en fil som du vil lagre som Dockerfile, uten filutvidelser.

I denne DockerFile eksisterer alle kommandoene som brukes til å sette sammen et Docker -bilde. Selv om du kan sende disse kommandoene inn i Docker CLI når du bygger et bilde, vil du være enig i at det er bedre praksis å ha en fil for det, slik at ting kan være bedre organisert.

Kommandoene i Dockerfile er avgjørende for å bygge et Docker -bilde.

Her er grunnen:

Hver kommandolinje i Dockerfile oppretter lagene som utgjør Docker -bildet. Forutsatt at Dockerfile forblir den samme, hver gang du bygger et bilde av det, er det sikkert at du vil få de samme resultatene. Imidlertid, når du legger til en ny kommandolinje, bygger Docker ganske enkelt det laget og legger det til de eksisterende lagene.

Akkurat som kompilatoren eller tolk gjør for programmeringsspråk, leser Docker Dockerfile fra topp til bunn. Derfor er plasseringen av kommandoene mye.

I motsetning til de fleste programmeringsspråk, er kommandoene i Dockerfile ikke saksfølsomme. Men du vil se fra eksempler på dockerfiles at kommandoene er skrevet i store bokstaver. Dette er ingenting annet enn et stevne, som du også bør følge.

Som programmeringsspråk, kan du skrive kommentarer i Dockerfiles. Kommentarer i Dockerfiles er betegnet ved å bruke hasj- eller pundsymbolet # I begynnelsen av linjen. Du må merke deg at den bare støtter en-linjekommentarer, og for å skrive multi-line kommentarer, vil du bruke hasjsymbolet på hver linje.

Forsiktig, ikke alle hasjsymboler du ser i en dockerfile er kommentarer. Hash -symboler kan også indikere Parser -direktiver. Parser -direktiver er kommandoer i Dockerfile som indikerer hvordan Dockerfile skal leses.

Bare to parser -direktiver er tilgjengelige på Docker som i skrivende stund denne artikkelen. De er flukt og Syntaks Parser -direktiver. De Syntaks Direktiv er bare tilgjengelig på Docker når det kjører på en buildkit backend.

De flukt Direktiv fungerer overalt. De flukt Direktivet lar deg bestemme hvilket symbol Docker bruker som en rømningskarakter.

Du kan ha i Dockerfile, en linje som ligner på den nedenfor:

Kopierindeks.HTML C: \\ Dokumenter

Du bør ikke bry deg om hva kommandoen gjør ennå, fokuser på filplassen. Å bruke kommandoen over i et Windows -basert Docker -bilde, er gyldig. Men du vil huske at Docker er Linux -basert, så den bruker tilbakeslaget \ som en rømningskarakter på grunn av Linux -konvensjoner. Derfor, når Docker leser gjennom Dockerfile, vil den slippe unna tilbakeslaget i stedet for å lese den som en filsti.

For å endre denne oppførselen, vil du bruke flukt Parser -direktiv som vist nedenfor:

# flukt = '

Dette direktivet får Docker til å bruke backtick som en rømningskarakter, i stedet for tilbakeslaget. For å bruke parser-direktivet, må du legge det til toppen av Dockerfile, ellers vil det bare telle som en kommentar-du må legge den til og med kommentarer, hvis du har kommentarene øverst i filen.

DockerFile -instruksjoner

Docker er avhengig av hver kommandolinje i Dockerfile og utfører dem, og bygger et lag for hver linje i prosessen.

Du trenger en forståelse av kommandoene for å skrive Dockerfiles. Et forsiktighetspunkt: Mange av Dockerfile -kommandoene gjør lignende ting. Du trenger ikke å bekymre deg, du får forstå disse kommandoene også.

Her er en liste over kommandoene du lærer om:

• FRA
• MERKELAPP
• Env
• AVDEKKE
• LØPE
• KOPIERE
• Workdir
• CMD

FRA

Husk at hovedmålet med Docker er å virtualisere ting på operativsystemet (OS), ved å lage containere. Derfor, uansett hvor bilde Docker som bygger fra DockerFile, må være basert på et eksisterende OS-bortsett fra at du bygger et basisbilde.

Fra -kommandoen brukes til å oppgi hvilket operativsystem du har tenkt å bruke som basisbilde. Hvis du har tenkt å bygge på et basisbilde, fra kommandoen må Vær den første kommandoen i dockerfile-asides parser-direktiver og kommentarer.

MERKELAPP

Dockerfile trenger metadata, og etikettkommandoen er hva du vil bruke for å lage dem. Etter å ha bygget et bilde og kjørt en beholder av det, kan du bruke Docker inspiser Kommando for å finne informasjon om beholderen.

Env

Miljøvariabler. Kjente ord? Vel, Env -kommandoen brukes til å angi miljøvariabler mens du bygger Docker -bildet. Du får også se at de faste miljøvariablene også er tilgjengelige etter lansering av beholderen.

Dockerfile har en kommando som ligner env, kjent som Arg. Uansett hvilken miljøvariabel er satt ved hjelp av ARG er imidlertid bare tilgjengelig mens du bygger bildet, men ikke etter å ha lansert beholderen.

AVDEKKE

På samme måte som din Docker-vert-din lokale maskin er Docker-verten i denne case-Has-portene for kommunikasjon som 8080, 5000 osv. er på samme måte som Docker -containere har porter.

Du vil bruke Expose -kommandoen for å velge hvilke porter som skal være tilgjengelige for å kommunisere med en container.

Når du kjører Docker -containere, kan du passere i -p argument kjent som publiser, som ligner på eksponeringskommandoen.

Her er den subtile forskjellen: du bruker eksponeringskommandoen for å åpne porter for andre Docker -containere, mens -p Argument brukes til å åpne porter for det ytre miljøet i.e. utenfor Docker -beholderen.

Hvis du ikke bruker eksponering eller -p I det hele tatt vil ikke Docker -beholderen være tilgjengelig gjennom noen porter fra utenfor beholderen eller andre Docker -containere.

LØPE

Når du bygger et Docker -bilde, kan det hende du må kjøre kommandoer av grunner som å installere applikasjoner og pakker for å være en del av bildet.

Ved hjelp av Run -kommandoen kan du gjøre alt dette. Men husk: Kommandoer kjøres bare når du bygger Docker -bildet.

KOPIERE

Det er forskjellige grunner til å kopiere filer fra Docker -verten din til Docker -bildet ditt. Noen filer du kanskje vil kopiere, kan være konfigurasjonsfiler, eller kildekoden-hvis du kjører den i Docker Container.

For å kopiere filer fra Docker -verten din til et Docker -bilde, kan du bruke Copy -kommandoen.

Det er add -kommandoen som ligner på Copy, og er litt annerledes. Mens kopi bare kan kopiere filer fra Docker -verten din til Docker -bildet, kan du legge til kan kopiere filer fra en URL og også trekke ut komprimerte filer til Docker -bildet.

Hvorfor bruke kopi i stedet for å legge til? Vel, du vil finne ut kopiering av filer fra en URL er en oppgave du kan kjøre med Curl ved hjelp av Run -kommandoen. Du kan også trekke ut filer i Docker -bildet ved å bruke Run -kommandoen også.

Imidlertid er det ingenting galt med å bruke ADD for å trekke ut komprimerte filer direkte i Docker -bildet.

Workdir

Husk løpskommandoen? Du kan bruke RUN -kommandoen til å utføre kommandoer i Docker -bildet ditt. Noen ganger har du imidlertid en grunn til å kjøre en kommando i visse kataloger. For å pakke ut en fil, må du være i katalogen til ZIP -filen eller peke på den.

Det er der Workdir kommer godt med. WorkDir lar deg endre katalog mens Docker bygger bildet, og den nye katalogen er fortsatt den gjeldende katalogen for resten av byggeinstruksjonene.

CMD

Docker -beholderen din er vanligvis satt opp for å kjøre en prosess. Men hvordan vet den hvilken prosess du skal løpe? Det er gjennom CMD -kommandoen. CMD -kommandoen brukes til å utføre kommandoer når Docker lanserer Docker -beholderen fra bildet.

Mens du kan spesifisere kommandoen som skal kjøres når du lanserer fra kommandolinjen, forblir kommandoene som er angitt ved CMD-instruksjonen standard.

Docker kan bare kjøre en CMD -kommando. Derfor, hvis du setter inn to eller flere CMD -instruksjoner, ville Docker bare kjøre den siste jeg.e. den siste.

EntryPoint ligner på CMD, men du kan kjøre kommandoer mens du lanserer, og det vil ikke overstyre instruksjonene du har definert på EntryPoint.

Eksempel

I dette eksemplet vil du se en implementering av nesten alle kommandoene omtalt ovenfor. Du vil se hvordan en kolbeapplikasjon vil bli kjørt i en Docker -beholder. Hvis du ikke vet hva kolben er, er Flask et nettramme skrevet i Python for å bygge webapplikasjoner.

Det er ganske enkelt, så du trenger ikke å ha noen kunnskap om språket for å kjøre eksemplet.

Til å begynne med, må du installere git på maskinen din. Etter å ha installert Git, kloner du kildekoden fra GitHub -depotet her.

Først må du lage en ny katalog. Du har kildekoden og Dockerfile i denne katalogen. Du kan opprette en katalog-du kan kalle det Docker-prøve-og Dockerfile ved å bruke kommandoene nedenfor:

mkdir docker-prøve && cd docker-prøve
Berør dockerfile

Husk at Dockerfile er bare en vanlig tekstfil? Du husker også at det ikke burde ha .tekst Utvidelse? Du finner den diskusjonen i begynnelsen av delen “Inside the Dockerfile”, hvis du gikk glipp av den.

Deretter vil du laste ned kildekoden fra GitHub ved å bruke git klon Kommando som vist nedenfor:

git klon https: // github.com/craigkerstiens/kolbe-helloworld.git

Du kan sjekke innholdet i Flask-Helloworld Katalog:

LS Flask-Helloworld

Du vil se følgende filer:

• Markdown.RST: Den inneholder detaljene i prosjektet, men ikke viktig for dette eksemplet. Du skal ikke være bekymret for det.
• Procfile: Den inneholder kommandoer for å kjøre prosjektene på en server. Du skal ikke være bekymret for det heller.
• app.py: Den inneholder koden du kjører i Docker -beholderen.
• Krav.tekst: Den inneholder avhengighetene app.py Filen må kjøre vellykket.

Skrive Dockerfile

Denne Dockerfile har alle docker -instruksjonene omtalt ovenfor. Den har også kommentarer i seg, for å hjelpe deg med å forstå hva hver linje gjør.

# Fra instruksjon velger foreldrebildet for Docker.
# Dette eksemplet bruker Alpine.
# Alpine er et minimalt Docker -bilde veldig lite i størrelse
Fra Alpine: 3.3

# Etikettinstruksjon lager etiketter.
# Den første etiketten er vedlikeholder med verdien Linux -hint.
# Den andre etiketten er appnavn med verdikolpen hei. Verden
# Du kan ha så mange nøkkel-til-verdi-par som du vil.
# Du kan også velge hvilket som helst navn for nøklene.
# Valget av vedlikeholder og appnavn i dette eksemplet
# er et personlig valg.
Etikett "vedlikeholder" = "Linux hint" "AppName" = "Flask Hello World"

# Env -instruksjon tildeler miljøvariabler.
# Datalog /usr /src katalog har nedlastede programmer,
# være det kilde eller binær før du installerer dem.
Env applokasjon /usr /src

# Kopier instruksjon kopierer filer eller kataloger,
# fra Docker -verten til Docker -bildet.
# Du kopierer kildekoden til Docker -bildet.
# Kommandoen nedenfor bruker den faste miljøvariabelen.
Kopier Flask-Helloworld $ Applocation/Flask-Helloworld

# Bruke Env -instruksjonen igjen.
Env flaskapp $ applikasjon/kolbe-helloworld

# WorkDir -instruksjonen endrer gjeldende katalog i Docker -bildet.
# Kommandoen nedenfor endrer katalog til/usr/src/kolbe-helloworld.
# Målkatalogen bruker miljøvariabelen.
WorkDir $ FlaskApp/

# Kjør instruksjon kjører kommandoer,
# Akkurat som du gjør på terminalen,
# Men i Docker -bildet.
# Kommandoen nedenfor installerer Python, Pip og appavhengighetene.
# Avhengighetene er i kravene.txt -fil.
Kjør apk add-Update python py-pip
Kjør Pip Install -Upgrade Pip
Kjør Pip Install -r -krav.txt # utsett instruksjon åpner porten for å kommunisere med Docker -beholderen.
# Flask -appen bruker Port 5000, så du eksponerer Port 5000.
Eksponere 5000 # CMD -instruksjonskjører som kjører,
# Men kommandoene kjøres når Docker -containeren lanseres.
# Bare en CMD -instruksjon kan brukes.
CMD ["Python", "App.py "]

Bygge Docker -bildet

Etter å ha skrevet Dockerfile, kan du bygge Docker -bildet med kommandoen nedenfor:

sudo docker build -t sample_image .

Her, prøve_image er navnet på Docker -bildet. Du kan gi det et annet navn. Prikken (.) På slutten av kommandoen indikerer at filene du jobber med er i den gjeldende katalogen.

Kjører Docker -beholderen

For å kjøre Docker -beholderen, kan du bruke Docker Run Kommando nedenfor:

Sudo Docker Run -IP 5000: 5000 Sample_image: Siste

-I -parameteren sikrer at Docker -beholderen kjører i interaktiv modus, og -P -parameteren binder Docker -vertens port til Docker -beholderens port. Tenk på det som: Docker-vert: Docker-Container.

Etter å ha lansert Docker -beholderen, kan du besøke LocalHost: 5000 i nettleseren din for å se resultatene av Flask -applikasjonen.

Konklusjon

Dockerfile er blåkopien for et Docker -bilde. Å forstå hvordan Dockerfiles fungerer, og å kunne skrive dem komfortabelt vil gjøre Docker -opplevelsen din en hyggelig.

Arbeidet mot dette gjennom denne artikkelen, har du sett hvordan Dockerfiles fungerer. Forhåpentligvis forstår du også hva de store Docker -instruksjonene betyr og kan kunne bruke dem til å bygge dine egne Docker -bilder.

Ethvert spørsmål du har relatert til dockerfiles vil være velkomne. Takk for at du leste.