Programmering

Docker-opplæring: Kom i gang med Docker

Beholdere gir en lett måte å ta applikasjonsarbeidsbelastninger bærbare, som en virtuell maskin, men uten overhead og bulk som vanligvis er knyttet til virtuelle maskiner. Med containere kan apper og tjenester pakkes opp og flyttes fritt mellom fysiske, virtuelle eller skymiljøer.

Docker, et containeropprettings- og styringssystem opprettet av Docker Inc., tar den opprinnelige containerfunksjonaliteten som finnes i Linux og gjør den tilgjengelig for sluttbrukere gjennom et kommandolinjegrensesnitt og et sett med APIer.

Mange vanlige applikasjonskomponenter er nå tilgjengelige som ferdigpakkede Docker-containere, noe som gjør det enkelt å distribuere programvarestabler som frakoblede komponenter (mikroservicemodellen). Når det er sagt, hjelper det å vite hvordan brikkene passer sammen fra innsiden og ut.

I denne guiden installerer jeg således Apache-webserveren i en Docker-container og undersøker hvordan Docker fungerer underveis.

Installer Docker

Jeg bruker Ubuntu som grunnlaget for Docker-bygningen. Ubuntu er ikke bare en populær og mye brukt distribusjon, men Docker-teamet bruker selv Ubuntu for utvikling, og Docker støttes på Ubuntu Server fra versjoner 12.04 og oppover. For enkelhets skyld begynner jeg med instruksjoner når jeg bruker en ny installasjon av Ubuntu 16.04.

Forbered Ubuntu Linux for Docker

Det første du må gjøre er å skaffe riktig versjon av kjernen og dens overskrifter:

$ sudo apt-get install - install-anbefaler linux-generic-hwe-16.04

Denne prosessen kan ta litt tid og vil kreve omstart når du er ferdig:

$ sudo omstart

Du må kanskje også oppgradere andre pakker i systemet etterpå:

$ sudo apt-get oppdatering

$ sudo apt-get upgrade

Installer Docker på Ubuntu

Installasjon av Docker på CentOS, Fedora, Debian, Ubuntu og Raspbian Linux-distribusjoner er gjort enkelt ved hjelp av et skallskript som du kan laste ned fra //get.docker.com/. For det trenger du krølle kommando. For å få den nyeste versjonen av krølle:

sudo apt-get install curl

Når du har krølle installert, hent installasjonsskriptet og sett det i gang:

krølle -s //get.docker.com | sudo sh

Når skriptet er ferdig installert, ser du et notat som følgende, med installasjonsdetaljer om versjonen av Docker, både klienten og serverkomponentene:

Legg merke til detaljene nederst om å legge til brukere som ikke er root i Docker. Det er praktisk å gjøre dette, men hvis du gjør det, anbefales det å opprette en ikke-root-bruker spesielt for å jobbe med Docker og for ingen andre funksjoner. Av hensyn til denne veiledningen holder jeg meg imidlertid med å bruke sudo å kjøre Docker ved hjelp av en ikke-privilegert bruker.

Nå kan du teste ut en grunnleggende Docker-container:

$ sudo docker kjør -i -t ubuntu / bin / bash

Denne kommandoen laster ned det generiske Docker Ubuntu-bildet (i henhold til ubuntu parameter) og kjør / bin / bash kommandoen i den beholderen. De -Jeg og -t alternativene åpner henholdsvis standardinngang og en pseudo TTY.

Hvis det lykkes, bør du se vertsnavnet i ledeteksten endre til noe lignende root @ 216b04387924: / #, som indikerer ID-nummeret (og vertsnavnet) til den nye kjørende containeren. For å gå, skriv exit, samme som du ville forlatt en shell-økt.

Du bør nå ha en funksjonell Docker-installasjon på serveren din. Du kan teste det og få grunnleggende informasjon ved hjelp av docker info kommando:

$ sudo docker info

Resultatet av docker info kommandoen viser antall containere og bilder, blant annet relevant informasjon. Merk at den kan være ganske lang; dette eksemplet viser bare den siste av to sider.

En siste endring du må gjøre hvis du kjører Ubuntus UFW-brannmur, er å tillate videresending av pakker. Du kan sjekke om UFW kjører ved å skrive inn følgende:

$ sudo ufw status

Hvis kommandoen returnerer statusen inaktiv, kan du hoppe over dette neste trinnet. Ellers må du redigere UFW-konfigurasjonsfilen / etc / default / ufw og endre policyen for videresending fra MISTE til AKSEPTERER. For å gjøre dette ved hjelp av Nano-editoren, skriv inn følgende:

$ sudo nano / etc / default / ufw

Og endre denne linjen:

DEFAULT_FORWARD_POLICY = "DROP"

Til dette:

DEFAULT_FORWARD_POLICY = "ACCEPT"

Lagre filen, og kjør deretter:

$ sudo ufw reload

Arbeid med Docker-bilder og Docker-containere

Docker-containere er mye mer effektive enn virtuelle maskiner. Når en container ikke kjører en prosess, er den helt sovende. Du kan tenke på Docker-containere som selvstendige prosesser. Når de ikke kjører aktivt, bruker de ingen ressurser bortsett fra lagring.

Du kan se aktive og inaktive containere ved hjelp av docker ps kommando:

# Denne kommandoen viser ALLE containere på systemet

$ sudo docker ps -a

# Dette viser bare LØPENDE containere

$ sudo docker ps

Du kan se alle tilgjengelige kommandoer ved å skrive inn docker. For en oppdatert oversikt over alle kommandoer, deres valg og fullstendige beskrivelser, se den offisielle kommandolinjeklientdokumentasjonen.

Da jeg løp docker kjøre tidligere, kommandoen automatisk trakk et Ubuntu-containerbilde fra Docker Hub-registertjenesten. Det meste av tiden vil du imidlertid trekke containerbilder inn i den lokale cachen på forhånd, i stedet for å gjøre det på forespørsel. For å gjøre det, bruk docker pull, som dette:

$ sudo docker pull ubuntu

En fullstendig, søkbar liste over bilder og arkiver er tilgjengelig på Docker Hub.

Docker-bilder kontra containere

Noe som er verdt å stave ut på dette tidspunktet er hvordan bilder, containere og pull / push-prosessen fungerer sammen.

Docker-containere er bygget fra Bilder, som i det vesentlige er skall av operativsystemer som inneholder de nødvendige binærfiler og biblioteker for å kjøre applikasjoner i en container.

Bilder er merket medkoder, i hovedsak metadata, som gjør det enkelt å lagre og hente forskjellige versjoner av et bilde. Naturligvis kan et enkelt bilde assosieres med flere tagger: ubuntu: 16.04, ubuntu: xenial-20171201, ubuntu: xenial, ubuntu: siste.

Da jeg skrev docker pull ubuntu tidligere trakk jeg standard Ubuntu-bildet fra Ubuntu-depotet, som er bildet merket siste. Med andre ord kommandoen docker pull ubuntu tilsvarer docker pull ubuntu: siste og (i skrivende stund) docker pull ubuntu: xenial

Merk at hvis jeg hadde skrevet:

$ sudo docker pull-en ubuntu

Jeg ville ha pullet alle bilder ( -en flagg) i Ubuntu-depotet til mitt lokale system. Mesteparten av tiden vil du imidlertid ha enten standardbildet eller en spesifikk versjon. Hvis du for eksempel vil ha bildet til Ubuntu Saucy Salamander, vil du bruke det docker pull -a ubuntu: saucy å hente bildet med den aktuelle koden fra den repoen.

Den samme logikken bak repoer og tagger gjelder andre manipulasjoner av bilder. Hvis du trakk saftig i henhold til eksemplet ovenfor, vil du kjøre det ved å skrive sudo docker run -i -t ubuntu: saucy / bin / bash. Hvis du skriversudo docker image rm ubuntu, for å fjerne ubuntu bildet, fjerner det bare bildet som er merket siste . For å fjerne andre bilder enn standard, for eksempel Ubuntu Saucy, må du inkludere riktig tag:

sudo docker image rm ubuntu: saucy

Docker image og container arbeidsflyt

Tilbake til å jobbe med bilder. Når du har tegnet et bilde, uansett hva det måtte være, oppretter du en live container fra det (som jeg har vist) ved å utføre docker kjøre kommando. Etter at du har lagt til programvare og endret innstillinger i containeren, kan du opprette et nytt bilde fra disse endringene ved å bruke docker begå kommando.

Det er viktig å merke seg at Docker bare lagrer deltas eller endringer i bilder bygget fra andre bilder. Når du bygger dine egne bilder, blir bare endringene du gjør i basisbildet lagret i det nye bildet, som lenker tilbake til basisbildet for alle dets avhengigheter. Dermed kan du lage bilder som har en virtuell størrelse på 266MB, men tar bare noen få megabyte på disken på grunn av denne effektiviteten.

Fullt konfigurerte containere kan deretter skyves opp til et sentralt depot som skal brukes andre steder i organisasjonen eller til og med deles offentlig. På denne måten kan en applikasjonsutvikler publisere en offentlig container for en app, eller du kan opprette private arkiver for å lagre alle containere som brukes internt av organisasjonen din.

Opprett et nytt Docker-bilde fra en container

Nå som du har bedre forståelse av hvordan bilder og containere fungerer, la oss sette opp en Apache webservercontainer og gjøre den permanent.

Start med en ny Docker-container

Først må du bygge en ny container. Det er noen måter å gjøre dette på, men fordi du har noen kommandoer å kjøre, kan du starte et rotskall i en ny container:

$ sudo docker kjør -i -t --navn apache_web ubuntu / bin / bash

Dette skaper en ny container med en unik ID og navnet apache_web. Det gir deg også et rotskall fordi du spesifiserte / bin / bash som kommandoen til å løpe. Installer nå Apache-webserveren ved hjelp av apt-get:

root @ d7c8f02c3c8c: / # apt-get oppdatering

root @ d7c8f02c3c8c: / # apt-get installer apache2

Merk at du ikke trenger å bruke sudofordi du kjører som rot inne i containeren. Legg merke til at du gjøre trenger å løpe apt-get oppdatering, fordi, igjen, pakkelisten inne i containeren er ikke den samme som den utenfor den.

Det normale apt-get output vises, og Apache2-pakken er installert i den nye beholderen. Når installasjonen er fullført, start Apache, installer krøll og test installasjonen, alt fra containeren din:

root @ d7c8f02c3c8c: / # service apache2 start

root @ d7c8f02c3c8c: / # apt-get install curl

root @ d7c8f02c3c8c: / # curl // localhost

Etter den siste kommandoen, bør du se den rå HTML-en til standard Apache-siden som vises i konsollen. Dette betyr at Apache-serveren vår er installert og kjører i beholderen din.

Hvis du gjorde dette i et produksjonsmiljø, vil du konfigurere Apache til dine behov og installere et program for at det skal fungere. Docker letd kataloger utenfor en container blir kartlagt til stier inne i den, så en tilnærming er å lagre webappen din i en katalog på verten og gjøre den synlig for containeren gjennom en kartlegging.

Opprett et oppstartsskript for en Docker-container

Husk at en Docker-container bare kjører så lenge prosessen eller prosessene er aktive. Så hvis prosessen du starter når du først kjører en container, beveger seg i bakgrunnen, som en systemdemon, stopper Docker beholderen. Derfor må du kjøre Apache i forgrunnen når beholderen starter, slik at beholderen ikke går ut så snart den fyres opp.

Opprett et skript, startapache.sh, i / usr / local / sbin:

# Du må kanskje først installere Nano inne i containeren

root @ d7c8f02c3c8c: / # apt-get install nano

root @ d7c8f02c3c8c: / # nano /usr/local/sbin/startapache.sh

I filen startapache.sh legger du til disse linjene:

#! / bin / bash

. / etc / apache2 / envvars

/ usr / sbin / apache2 -D FOREGROUND

Skriv endringene og lagre filen. Gjør den deretter kjørbar:

root @ d7c8f02c3c8c: / # chmod + x /usr/local/sbin/startapache.sh

Alt dette lille skriptet gjør er å bringe inn passende miljøvariabler for Apache og starte Apache-prosessen i forgrunnen.

Du er ferdig med å endre innholdet i beholderen, slik at du kan forlate beholderen ved å skrive exit. Når du går ut av containeren, stopper containeren.

Forplikt beholderen til å opprette et nytt Docker-bilde

Nå må du begå beholderen for å lagre endringene du har gjort:

$ sudo docker begå apache_web lokal: apache_web

Forpliktelsen vil lagre beholderen din som et nytt bilde og returnere en unik ID. Argumentet lokal: apache_web vil føre til at forpliktelsen plasseres i et lokalt depot med navnet lokal med en tagg av apache_web.

Du kan se dette ved å kjøre kommandoen sudo docker bilder:

REPOSITORY TAG BILDE-ID LAGET VIRTUELL STØRRELSE

lokal apache_web d95238078ab0 for 4 minutter siden 284,1 MB

Vær oppmerksom på at de eksakte detaljene i bildet ditt - bilde-ID, størrelsen på beholderen - vil være forskjellige fra mitt eksempel.

Docker-containere er designet for å væreuforanderlig. Hver gang du foretar endringer i en container, blir resultatene skrevet ut til en helt ny container, aldri til originalen. Hvis du vil bytte ut Apache med, si Nginx, vil du starte med originalen ubuntu: siste container, legg til Nginx i det, og lagre resultatene som en helt ny container som heter noe sånt lokal: nginx.

Forstå grunnleggende om Docker-nettverk

Nå som du har bildet vårt, kan du starte containeren vår og begynne å vise sider. Før du gjør det, la meg imidlertid ta et øyeblikk for å forklare hvordan Docker håndterer nettverk.

Når Docker er installert, oppretter den tre virtuelle nettverk som kan brukes av Docker-containere:

  • bro: Dette er nettverket som containere kobles til som standard. Bridge-nettverket lar containere snakke med hverandre direkte, men ikke til vertssystemet.
  • vert: Dette nettverket lar containere bli sett av verten direkte, som om noen apper i dem kjørte som lokale nettverkstjenester.
  • ingen: Dette er egentlig et null- eller loopback-nettverk. En container som er koblet til ingen, kan ikke se annet enn seg selv.

Når du vil starte en container og få den til å kommunisere med både andre containere og omverdenen, må du manuelt tilordne porter fra den containeren til verten. Av hensyn til mitt eksempel kan du gjøre dette på kommandolinjen når du starter den nyopprettede beholderen:

$ sudo docker kjør -d -p 8080: 80 --navn apache lokalt: apache_web /usr/local/sbin/startapache.sh

Copyright no.verticalshadows.com 2024

$config[zx-auto] not found$config[zx-overlay] not found