286 total views, 1 views today
Anders Fongen, september 2022
Dette er et blogginnlegg som skal diskutere nettverk av Docker-kontainere, hvordan de kan kommunisere gjennom beskyttede interne nett, og hvordan de kan opptre i svermer under styring av en sentral kontrollnode. Forutsetningen for å få godt ubytte av denne teksten er grunnleggende kjennskap til bygging og kjøring av vanlige Docker-komponenter (eng. images)
Vi kan enkelt tenke oss fornuftige anvendelser hvor en Docker-komponent har nytte av å påkalle tjenester fra en annen komponent. Dette er da typisk en komponent som ikke betjenes med en HTML-basert web -dialog, men som benytter maskin-til-maskin kommunikasjon (m2m). Slik kommunikasjon kan gjerne være basert på HTTP-protokoll og benytte programmeringsbiblioteker for dette, men vil ha innholdet kodet med XML eller JSON. Slike komponenter forbinder vi med begrepet Service Oriented Architecture (SOA). Jeg kommer ikke til å komme inn på slik programmering her, men det finnes mengder av læremidler der ute basert på ditt favoritt programmeringsspråk.
Beskyttet nettverk internt i Docker
Når en komponent ønsker å kalle en annen, er det selvfølgelig mulig å utplassere den kalte komponenten slik at den kan kalles fra “utsiden” (evt. hele Internet) og bruke denne utvendige IP-adressen som servicepunkt. Det er lett å tenke seg hvorfor dette ofte ikke er ønskelig: Uvedkommende kan fritt utnytte og sabotere tjenesten med mindre man lager mekanismer for adgangskontroll, noe som strengt tatt ikke burde vært nødvendig.
Docker tilbyr derimot “interne” nettverk som kun er synlig for Docker-kontainere på den samme maskinen og som er koplet til det interne nettverket. I det man skaper et slikt nettverk:$ docker network create my-internal-network
$ docker network ls
$ docker network inspect my-internal-network
vil det også bli tildelt en subnett-adresse, og forsynes med tjenester for tildeling av adresser fra subnettet (lik DHCP) og tjenester for å finne IP-adresser til de tilkoplede kontainerne (lik DNS). For siden å kople en kontainer til nettverket kan vi velge to metoder:
- Kople til nettverket i det kontaineren skapes, f.eks slik:
$ docker run -p 80:80 --name mycontainer --net my-internal-network image-name
Med denne metoden vil kontaineren mycontainer være knyttet til kun my-internal-network. Om kontaineren skal være knyttet til flere nettverk, bruk metode nr.2: - Lage kontaineren, kople til nettverket og starte programmet, i tre steg (eksempelvis)
$ docker create -p 80:80 -name mycontainer image-name
$ docker network connect my-internal-network mycontainer
$ docker network connect my-second-internal-network mycontainer
$ docker network disconnect bridge mycontainer
$ docker start mycontainer
Denne listen av kommandoen viser bruken avcreate
, som oppretter en kontainer uten å starte den,network connect
som kopler kontaineren til interne nettverk, ogdisconnect
, som kopler fra nettverk. Deretter starter kjøringen av programmet i kontaineren med$docker run
.
Det forholder seg nemlig slik at en kontainer som standardinnstilling koples til et nettverk kalt bridge
. Alle andre kontainere vil også ha forbindelse til denne, noe som i mange tilfeller ikke er ønskelig. Metode nr.1 vil erstatte bridge
-forbindelsen med en forbindelse til my-internal-network
. Metode nr.2 vil legge nye forbindelser til eksisterende.
Eksempel 1 – BusyBox
Som eksempel på viste metode nr.2 kan komponenten BusyBox brukes. Den gir et lite Linux-kjøremiljø som vi kan skrive kommandoer til.
Først lister vi opp eksisterende nettverk og skaper to nye:
Vi er interessert i å vite subnet-adressene til disse to nye nettene:
Vi skaper en kontainer med BusyBox-komponenten og knytter den til de to nye nettverkene, i tillegg til bridge
:
Nå starter vi kontaineren bb med BusyBox inni, og skriver kommandoen ip a
for å se nettverkskonfigurasjonen på komponenten:
Fra denne kommandoen ser vi de tre ethernet-adaptrene eth0
, eth1
og eth2
med subnettadresser som tilsvarer nettverkene bridge
, my-net-1
og my-net-2
. Som nevnt tidligere ville vi trolig koplet fra bridge
for å unngå påvirkning fra uvedkommende komponenter.
Eksempel 2 – Trafikk mellom to Docker-komponenter
Det første eksemplet viste kun konfigurasjon av nettverksforbindelser, ikke hvordan vi kan bruke dem. Derfor vil vi nå sette opp komponenten first
slik at vi kan kalle den fra busybox med linux-kommandoen wget
og vise html-innholdet som first sender. Komponenten first
er beskrevet i et tidligere blogginnlegg.
Her brukes kommandoene som er vist som metode nr.1 ovenfor og vi starter henholdsvis first
og busybox
med forbindelser til my-net-3
. I busybox
bruker vi kommandoene slik:
ip a
for å se at vi har fått et nettverksadapter med en adresse fra subnettet tilmy-net-3
ping first
for å vise at det foreligger en navnetjeneste som kopler navnetfirst
(navnet på kontaineren) til ip-adressen172.27.0.2
, og at det foreligger en virkelig forbindelse dit.wget first:8080
for å sende et http-forespørsel til172.27.0.2
, port8080
og lagre svaret på filenindex.html
.more index.html
for å vise innholdet av denne filen på konsollet.
Vi har altså med dette eksemplet demonstrert at to komponenter kan ha en nettverksforbindelse som er skjermet fra andre komponenter. Det som er verd å huske er:
- Interne nettverk får automatisk en subnett-adresse.
- Containere som kopler seg til et internt nettverk får tildelt IP-adresse automatisk.
- Interne nettverk (unntatt
bridge
) har en navnetjeneste som returnerer IP-adressen til navngitte containere. Derfor er det lurt å gi containere et navn med--name
parameteren.
Av en eller annen grunn er det ingen navntjeneste i nettverket bridge
, slik at ping first
ikke vil fungere dersom komponentene ønsket å kommunisere over det nettverket.
Docker-compose
En applikasjon vil gjerne bestå av flere Docker-containere som samarbeider og må konfigureres og startes på en kontrollert måte. Enkeltkommandoer som vist i eksemplene ovenfor kan kanskje settes sammen i en kommandofil (.bat, .sh
) og kjøres samlet. Dette forutsetter at du har konsoll-adgang til maskinen som skal kjøre applikasjonen, og at ulike maskiner kan forstå denne kommandofilen. Dette er forutsetninger som ikke kan garanteres. Docker-compose vil øke portabiliteten av applikasjoner og forenkle konfigurasjonen, siden alt foregår i én fil.
Derfor kommer Docker-compose inn som et verktøy hvor detaljer vedrørende konfigurasjon og kjøring for alle komponentene i applikasjon kan uttrykkes i én fil. Denne filen har en såkalt YAML-syntaks, som skal vises i eksemplet som følger.
Filen skal hete docker-compose.yml
. Som eksempel på utforming skal vi bruke konfigurasjonen i eksempel nr.2 ovenfor. Innholdet i filen er som vist under:
Syntaksen og mulige informasjonselementer i denne YAML-filer (uttales “jammel”) er ganske omfattende, og en oversikt finner du her. Derfor velger jeg heller å demonstrere ett bestemt kjent tilfelle med en typisk struktur: nettverksforbindelse, volumer, eksponerte porter. Elementene under disse to vil være tilsvarende de parametrene vi tidligere ga på kommandolinjen. For first, legg merke til at build: nå må ha et stinavn til der hvor kildefilene til first ligger.
Syntaksen i den viste docker-compose.yml
skal forstås som et hierarki der innrykk av teksten viser en “tilhørighet” til linjen ovenfor med kortere innrykk. Her har vi altså tre hovedkategorier: services, volumes, networks. Før en kontainer kan knyttes til et volum eller nettverk må disse først deklareres på denne måten. Under networks finner vi hvilket nett som skal brukes i applikasjonen og hva dette skal hete.
Under services finner vi de to vi har arbeidet med så langt, bb og firsts. For bb kommer det to linjer knyttet til stdin_open og tty, som har å gjøre med at vi ønsker konsolltilgang til denne kontaineren, noe som i mange tilfeller ikke vil være aktuelt. Derfor vil denne viste filen ha de fleste av de egenskapene du i praksis vil trenge.
La oss nå gi denne filen til Docker-compose og se hva som kommer ut av det. Arbeidskatalogen (current directory) må være den som inneholder docker-compose.yml . Oppstart skjer med kommandoen $ docker-compose up
:
Nå er både bb og first started i hver sine kontainere, men vi får ingen konsolltilgang til å skrive kommandoer i. Til forskjell fra eksempel nr.2 må vi skrive dette i tilegg:$ docker exec -it bb sh
Denne kommandoen utfører kommandoen sh
i kontaineren som heter bb
. Parameteren -it
gjør at sh
også kommuniserer med konsollet, så vi får en interaktivt Linux-konsoll. Nå kan vi teste at det er kommunikasjon mellom bb og first:
Dette må dog skrives i et annet CMD-vindu, fordi vinduet der vi startet docker-compose
er opptatt. Der kan vi derimot lukke applikasjonen og stanse kontainerne ved å trykke ctrl-C noen ganger:
Kommandoen $ docker ps -a
viser en liste over kontainerne og at disse er stoppet. Vi kan nå slette én og en kontainer med kommandoen $ docker rm bb first
, men en enklere måte er $ docker container prune
, som sletter alle inaktive kontainere under ett. Inaktive kontainere kan okkupere en del ressurser i systemet, og det er sunt å rydde regelmessig.
Docker swarms
I et storskala informasjonssystem vil en web-tjeneste kjøre på mange maskiner i parallell. Da oppnår man at maskinene kan fordele kundetrafikken mellom seg for å oppnå høyere total ytelse (kalt lastfordeling), og at noen av maskinene kan falle ut av drift uten at systemet som sådan blir utilgjengelig (kalt fail-over). Denne formen for ressursorganisering krever en sjef (manager), som fordeler forespørsler mellom arbeiderne (workers) og som holder oversikt ettersom maskiner går inn eller ut av drift.
Docker-arkitekturen egner seg godt til å inngå i en slik storskala arkitektur, siden tilstandsløse komponenter kan dupliseres på flere maskiner og utføre nøyaktig den samme tjenesten. Kunder vil se ett eneste servicepunkt (IP-adresse og port) og ikke merke noe til at tjenesten er fordelt på mange maskiner. La oss derfor se på hvordan Docker-komponenter kan organiseres som en Docker swarm:
Bruk helst Linux-maskiner
Selv om kommandoene for Docker-svermer også finnes på Windows-versjonen av Docker-systemet, er det en del egenskaper som simpelthen ikke virker som forventet. Det er derfor å anbefale at et eksperiment med Docker-svermer kun benytter Linux-maskiner. Husk også at Docker-komponenter ikke er arkitekturnøytrale, de kan ikke kjøre både på X86- og ARM-maskintyper. Ikke blande f.eks. Raspberry Pi (ARM) med ordinære PCer (X86) i en Docker-sverm.
Alt foregår fra sjefen
For å bygge opp en sverm må maskinene kunne nå hverandre gjennom et IP-nettverk, det er ikke tilstrekkelig at sjefen kan nå alle arbeiderne, arbeiderne må også kunne kommunisere med hverandre. For først å bygge opp en sverm gjør vi følgende:
- Bestem hvilke maskiner som skal delta, skriv ned deres IP-adresser og lag et kart som viser hvem som er sjef og hvem som er arbeidere. Fra konsollet til sjefen, logg inn (med
ssh
) på alle arbeiderne i separate konsollvinduer. Alle kommandoer som vises som eksempler må kjøres i sudo-modus (skrivsudo bash
for komme dit). - På alle maskinene i svermen, sørg nå for at alle kontainere er stanset (
$ docker stop ..., $ docker rm ...
) og kontroller resultatet med$ docker ps -a
. - På sjefens maskin, sjekk om det allerede er en sverm med
$ docker node ls
. Dersom det finnes en, fjerne dem med kommandoen$ docker swarm leave --force
. - På sjefens maskin, opprett en sverm med kommandoen
$ docker swarm init
. Reponsen kan se omtrent slik ut:Swarm initialized: current node (icv8b9vnemxfmym4lb1gbto7f) is now a manager
To add a worker to this swarm, run the following command:
docker swarm join --token SWMTKN-1-0ezzbg9iw2glu6d7xd6c2shjvhadr7zlemwuf4l9besxl2iogl-a1yngnqehgyub0phopuslysly 192.168.2.116:2377
- Ta en kopi av den uthevede teksten, og lim den inn i konsollvinduet til alle arbeiderne slik at kommandoen utføres der. De vil nå kople seg til sjefen (til ip-adressen som er vist i kommandoen) og slutte seg til svermen. Nå vil de etterhvert få opprettet kontainere for applikasjonstjenester og motta klientforespørsler.
- Fra sjefens konsoll skriv
$docker node ls
for å kontrollere at alle arbeiderne er kommet inn i svermen.
Utplassering av en tjeneste i svermen
Nå kan sjefen plassere en tjenesten inn i svermen. Dette betyr, som tidligere nevnt, at en applikasjon blir plassert ut på én eller flere av arbeiderne (inkludert sjefen), og en forespørsel fra en klient blir betjent av én av dem.
Hvilken IP-adresse leder inn til den utplassert tjenesten? Svaret er at alle IP-adressene i svermen (altså endepunktet til alle arbeiderne og sjefen) gir adgang til tjenesten, også de arbeiderne som ikke betjener selve tjenesten. Det eksisterer et eget “overlay” nettverk mellom maskinene som fremforhandler fordelingen av arbeidsoppgaver og som videresender forespørsler fra klienter til en kandidat-arbeider.
Kommandoen skal skrives på sjefens konsoll. Sånn kan den se ut:$ docker service create --name first --replicas 3 --publish 8080:8080 andfon7a/first
Den eneste nye parameteren siden de tidligere eksperimentene er --replicas
som angir det maksimale antall arbeidere (inkl. sjefen) som skal laste denne applikasjonen. Legg også merke til at Docker-komponenten ikke må ligge på sjefens egen maskin, den kan hentes fra Docker-hub om nødvendig (og den må da evt. plasseres der på forhånd med $ docker push andfon7a/first
).
Med kommandoen $ netstat -ant
på alle maskinene i svermen kan man nå konstatere at port 8080 er “åpen”. Med en web-leser kan man kontake én av maskinenes IP-adresse på port 8080 og konstatere at tjenesten utføres korrekt.
For å inspisere tjenesten bruk kommandoen $ docker service inspect --pretty first
. For å fjerne den skrives $ docker service rm first
.
Opp- og nedskalering: Det opplagt nyttige i svermen er muligheten for å endre kapasiteten ved å øke eller redusere antall maskiner som deltar i en tjeneste. Det gjøres som følger (i dette eksemplet reduseres antallet fra 3 til 2):
$ docker service scale first=2
Konklusjon
Målet med dette blogginnlegget var å gi en kortfattet, men ukomplett, innføring i hvordan man setter opp nettverk og svermer av Docker-komponenter. Det fulle omfanget av muligheter og detaljer er mye større, men er blitt utelatt fordi det er lagt vekt på å vise konkret hvor enkelt det er å sette opp en grunnleggende tjeneste.
Jeg anbefaler først leseren å gjennomføre disse eksemplene på eget utstyr og så gjøre nødvendige endringer etter egen interesse: F.eks. hvordan en sverm kan operere med permanent lagring gjennom en filtjener eller en SQL-database. Slike komponenter er ikke enkle å replikere i en sverm og vil naturlig ligge i egne tjenester, gjerne i frittstående Docker-kontainere med muligheter for å lagre data i volumes.