Docker Compose er et kraftig verktøy. Det sparer tid og reduserer feil når du distribuerer den dockeriserte applikasjonen. Vanligvis er det ikke en god idé å kjøre hele stabelen inkludert frontend, databaseserveren, osv. Fra innsiden av en enkelt en enkelt beholder.

Vi snurrer opp forskjellige containere for å håndtere forskjellige arbeidsmengder av en applikasjon, og vi bruker Docker -komponering for å gjøre dette enkelt. Hver logisk forskjellig arbeidsmengde er oppført som en annen service. For eksempel vil din frontend HTTP -server bli oppført som en frontend -tjeneste som kjører en Apache eller et Nginx -bilde som en container.

Alle tjenestene, deres nettverksbehov, lagringskrav osv.YML -fil. Vi vil fokusere på å spesifisere hukommelsesutnyttelse her.

Forutsetninger

Du trenger følgende verktøy i arsenalet ditt for å følge med:

1. Grunnleggende forståelse av Docker
2. Docker for Windows eller Mac, eller hvis du kjører Linux, Dock Commerce for Linux
3. Docker Compose Binary (Windows og Mac -brukere vil allerede ha dette installert)

Vi skal holde oss til versjonen 2.4 for vår Docker-komponering.YML -filer som det støtter versjon 17.12 og høyere av Docker -motoren og høyere. Vi kunne ha gått med versjon 3 som er nyere, men det støtter ikke Syntax for gammel minnebegrensning. Hvis du prøver å bruke den nyere syntaksen, insisterer den på å bruke Docker i svermmodus, i stedet. Så for å holde saken enkelt for vanlige Docker -brukere vil jeg holde meg til versjon 2.4

Det meste av koden vil fungere akkurat det samme for versjon 3, og hvor det vil være en forskjell, vil jeg nevne den nyere syntaksen for Docker Swarm -brukere.

Eksempel på applikasjon

La oss prøve å kjøre en enkel Nginx-tjeneste på port 80 ved å bruke First CLI og deretter en enkel Docker-Compose.yml. I neste avsnitt skal vi utforske dens hukommelsesbegrensninger og utnyttelse og endre vår Docker-komponering.YML for å se hvordan de tilpassede begrensningene blir pålagt.

La oss starte en enkel Nginx-server ved hjelp av Docker-CLI:

$ docker run -d -name my -nginx -p 80:80 nginx: siste

Du kan se Nginx -serveren jobbe ved å besøke http: // localhost eller erstatte lcoalhost

Med IP -adressen til Docker -verten din. Denne beholderen kan potensielt bruke hele det tilgjengelige minnet på Docker -verten din (i vårt tilfelle er det omtrent 2 GB). For å sjekke minneutnyttelsen, kan vi blant annet bruke kommandoen:

$ docker statistikk my-nginx
Container ID -navn CPU % MEM BRUK/Begrensning MEM % Net I/O Block I/O Pids
6EB0091C0CF2 MY-NGINX 0.00% 2.133MIB / 1.934gib 0.11% 3.14kb / 2.13KB 0B / 0B 2

MEM -bruken/grensen er på 2.133 mib ut av totalen 1.934gib. La oss fjerne denne beholderen og begynne å skrive Docker-Compose-skript.

$ docker stopp my-nginx
$ docker rm my-nginx

Tilsvarende YML -fil

Den nøyaktige beholderen som ovenfor kan opprettes hvis vi følger disse trinnene:

$ mkdir my-compose
$ CD My-Compose
$ Vim Docker-Compose.yml

Vi oppretter en ny tom katalog og oppretter en fildocker-kompose.yml i det. Når vi skal kjøre Docker-Compose Up fra denne katalogen, vil den se etter denne spesifikke filen (ignorerer alt annet) og opprette distribusjonen vår deretter. Legg til følgende innhold i dette .YML -fil.

Versjon: '3'
tjenester:
My-nginx:
Bilde: Nginx: Siste
Porter:
- "80:80"
$ docker -compose up -d

-D -flagget legges til slik at de nyopprettede containerne kjører i bakgrunnen. Ellers vil terminalen feste seg til containerne og begynne å skrive ut rapporter fra den. Nå kan vi se statistikken til den nyopprettede beholderen (e):

$ docker statistikk -alle
Container ID -navn CPU% MEM BRUK/Begrensning MEM% Net I/O Block I/O Pids
5f8a1e2c08ac my-compose_my-nginx_1 0.00% 2.25MIB/1.934gib 0.11% 1.65kb/0b 7.35MB/0b 2

Du vil merke at en lignende beholder som før ble opprettet med lignende minnegrenser og til og med utnyttelse. Fra samme katalog som inneholder YML -filen. Kjør følgende kommando for å slette den nyopprettede containeren, sammen med Customer Bridge Network som ble opprettet.

$ Docker-Compose Down

Dette vil returnere Docker til en ren tilstand med unntak av eventuelle volumer som ble opprettet (vi opprettet ikke noe, så det er ikke noe bekymring.)

Minnegrenser og minnestillinger

Minnegrenser og hukommelsesreservasjoner er to forskjellige aspekter for å sikre en jevn funksjon av applikasjonene dine og Docker -verten du kjører på toppen.

Stort sett pålegger minnegrensen en øvre grense for mengden minne som potensielt kan brukes av en Docker -beholder. Som standard kan en Docker -beholder, som alle andre systemprosesser, bruke hele tilgjengelige minnet til Docker -verten. Dette kan forårsake ut-av-minne-unntak, og systemet ditt kan veldig godt krasje. Selv om det aldri kommer til det, kan det fremdeles sulte annen prosess (inkludert andre containere) fra verdifulle ressurser, og igjen skade ytelsen. Minnegrensene sikrer at ressurssultne containere ikke overgår en viss grense. Dette begrenser eksplosjonsradiusen til en dårlig skriftlig applikasjon til noen få containere, ikke hele verten.

Minnreservasjoner er derimot mindre stiv. Når systemet går lite på minnet og prøver å gjenvinne noe av det. Den prøver å bringe beholderens minneforbruk ved eller under reservasjonsgrensen. Hvis det er en overflod av minne, kan applikasjonen imidlertid utvide seg opp til den harde settminnegrensen.

Å oppsummere:

1. Minnegrense: en streng øvre grense for mengden minne som er gjort tilgjengelig for en beholder.
2. Memoreservasjon: Dette bør settes som den blotte minimumsmengden som en applikasjon trenger å kjøre ordentlig. Så det krasjer ikke eller oppfører seg feil når systemet prøver å gjenvinne noe av minnet.

Hvis minneservasjon er større enn minnegrensen, har minnegrensen forrang.

Spesifisere minnegrenser og reservasjoner

Versjon 2

La oss gå tilbake til Docker-Compose.yml vi skrev tidligere og legger til en minnegrense for det. Endre versjonen til 2.4 Av grunner diskutert i forutsetningsdelen.

versjon: '2.4 '
tjenester:
My-nginx:
Bilde: Nginx: Siste
Porter:
- "80:80"
mem_limit: 300m

Den siste linjen setter grensen for My-Nginx-tjenesten til 300MIB. Du kan bruke K til KIB, og G for GIB og B for Just Bytes. Antallet før det må være et heltall. Du kan ikke bruke verdier som 2.4m, du må bruke 2400k i stedet. Nå hvis du løper:

$ Docker Stat --all
Container ID -navn CPU % MEM BRUK/Begrensning MEM % Net I/O Block I/O Pids
44114d785d0a my-compose_my-nginx_1 0.00% 2.141MIB/300MIB 0.71% 1.16kb/0b 0b/0b 2

Du vil merke at minnegrensen er satt til 300 MIB. Å sette minneservasjon er like enkelt, bare legg til en linje mem_reservation: xxx på slutten.

versjon: '2.4 '
tjenester:
My-nginx:
Bilde: Nginx: Siste
Porter:
- "80:80"
mem_limit: 300m
mem_reservation: 100m

Versjon 3 (valgfritt)

For å bruke versjon tre må du kjøre Docker i svermmodus. For Windows og Mac kan du aktivere den ved hjelp av Docker -innstillingsmenyen. Linux -brukere må løpe Docker Swarm Init. Mer informasjon om det finner du her. Det er ikke et nødvendig skritt, og hvis du ikke har aktivert det, er det også bra. Denne delen er for mennesker allerede Kjører i svermmodus og kan benytte seg av den nyere versjonen.

Versjon: '3'
tjenester:
My-nginx:
Bilde: Nginx: Siste
Porter:
- "80:80"
utplassere:
ressurser:
grenser:
Minne: 300m
reservasjoner:
Minne: 100m

Vi definerer alt dette under ressursalternativet. Grenser og reservasjoner blir primære nøkler og hukommelse er bare en av de mange ressursene som administreres her. CPU er nok en viktig parameter.

Mer informasjon

Du kan lære mer om Docker-komponering fra den offisielle dokumentasjonen som er koblet her. Når du har fått essensen av hvordan du skriver en komponeringsfil, kan dokumentasjonen hjelpe deg med detaljene forskjellige parametere.

Du trenger ikke å vite alt, bare søk etter hva applikasjonen din krever, og referansen vil veilede deg i å implementere det.