Förstå Docker

Jag har använt Docker i flera månader för att strukturera utvecklings-/leveransprocessen för webprojekt. Jag erbjuder läsarna på "Habr" en översättning av den introducerande artikeln om Docker — "Förstå Docker".

Vad är Docker?

Docker är en öppen plattform för utveckling, leverans och drift av applikationer. Docker är utformat för att snabbare distribuera dina applikationer. Med Docker kan du isolera din applikation från din infrastruktur och hantera infrastrukturen som en hanterad tjänst. Docker hjälper dig att distribuera din kod snabbare, testa snabbare, lansera applikationer snabbare och minska tiden mellan att skriva kod och köra den. Docker gör detta med en lättviktsplattform för containervirtualisering, med hjälp av processer och verktyg som hjälper till att hantera och distribuera dina applikationer.

I sin kärna låter Docker dig köra praktiskt taget vilken applikation som helst, säkert isolerad i en container. Den säkra isoleringen gör att du kan köra många containrar på en och samma värd samtidigt. Den lätta naturen hos containern, som körs utan extra belastning från en hypervisor, gör att du kan få mer ut av din hårdvara.

Plattformen och verktygen för containervirtualisering kan vara användbara i följande fall:

• paketering av din applikation (och även använda komponenter) i Docker-containrar;
• distribuering och leverans av dessa containrar till dina team för utveckling och testning;
• distribuering av dessa containrar till produktionen, både i datacenter och i molnet.

Vad kan jag använda Docker till?

Snabb distribution av dina applikationer

Docker är perfekt för att organisera utvecklingscykeln. Docker gör det möjligt för utvecklare att använda lokala containrar med applikationer och tjänster. Detta möjliggör senare integration med processen för kontinuerlig integration och distribution (CI/CD-arbetsflöde).

Till exempel skriver dina utvecklare kod lokalt och delar sin utvecklingsmiljö (uppsättning Docker-bilder) med kollegor. När de är redo, skickar de koden och containrarna till testmiljön och kör alla nödvändiga tester. Från testmiljön kan de skicka koden och bilderna till produktionen.

Enklare distribution och implementering

Den containerbaserade Docker-plattformen gör det enkelt att portera din arbetsbelastning. Docker-containrar kan köras på din lokala maskin, både på fysisk och virtuell maskin i datacentret, samt i molnet.

Portabiliteten och den lätta naturen hos Docker gör det enkelt att dynamiskt hantera din belastning. Du kan använda Docker för att distribuera eller stänga av din applikation eller tjänster. Docker ger en hastighet som gör detta möjligt nästan i realtid.

Höga belastningar och fler arbetsbelastningar

Docker är lättviktig och snabb. Den erbjuder en hållbar, kostnadseffektiv alternativ till virtuell maskin baserad på hypervisor. Den är särskilt användbar under hög belastning, exempelvis vid skapande av ett eget moln eller plattform som tjänst (platform-as-service). Men den är också användbar för små och medelstora applikationer när du vill få mer ut av dina befintliga resurser.

Huvudkomponenter i Docker

Docker består av två huvudkomponenter:

• Docker: en plattform för virtualisering med öppen kod;
• Docker Hub: vår plattform som tjänst för distribution och hantering av Docker-containrar.

Obs! Docker distribueras under Apache 2.0-licensen.

Docker-arkitektur

Docker använder en klient-server-arkitektur. Docker-klienten kommunicerar med Docker-demonen, som tar hand om tyngden av att skapa, köra och distribuera dina containrar. Både klient och server kan köras på samma system, och du kan ansluta klienten till en extern Docker-demon. Klienten och servern kommunicerar via en socket eller via ett RESTful API.

Docker-demon

Som visas i diagrammet körs demon på värdmaskinen. Användaren interagerar inte direkt med servern utan använder klienten för detta.

Docker-klient

Docker-klienten, programmet Docker, är huvudgränssnittet till Docker. Den får kommandon från användaren och interagerar med Docker-demonen.

Inuti Docker

För att förstå vad Docker består av, måste du veta om tre komponenter:

• bilder (images)
• register (registries)
• containrar

Avbilder

En Docker-avbildning är en read-only mall. Till exempel kan en avbildning innehålla operativsystemet Ubuntu med Apache och en applikation på den. Avbildningar används för att skapa containrar. Docker gör det enkelt att skapa nya avbildningar, uppdatera befintliga, eller så kan du ladda ner avbildningar skapade av andra. Avbildningar är en komponent av Docker.

Register

Docker-registret lagrar avbildningar. Det finns offentliga och privata register där du kan ladda ner eller ladda upp avbildningar. Det offentliga Docker-registret är Docker Hub. Här lagras en enorm samling avbildningar. Som du vet kan avbildningar skapas av dig, eller så kan du använda avbildningar skapade av andra. Register är en komponent av distribution.

Containrar

Containrar liknar kataloger. I containrar finns allt som behövs för att köra en applikation. Varje container skapas från en avbildning. Containrar kan skapas, startas, stoppas, flyttas eller tas bort. Varje container är isolerad och är en säker plattform för applikationen. Containrar är en komponent av driften.

Hur fungerar då Docker?

Vi vet så här långt att:

• vi kan skapa avbildningar som innehåller våra applikationer;
• vi kan skapa containrar från avbildningar för att köra applikationer;
• vi kan distribuera avbildningar genom Docker Hub eller ett annat avbildningsregister.

Låt oss se hur dessa komponenter sammanfaller.

Hur fungerar en avbildning?

Vi vet redan att en avbildning är en read-only mall från vilken en container skapas. Varje avbildning består av en uppsättning lager. Docker använder union file system för att kombinera dessa lager till en avbildning. Union file system tillåter filer och kataloger från olika filsystem (olika grenar) att transparent överlagras och skapa ett enhetligt filsystem.

En av anledningarna till att Docker är lättviktig är användningen av sådana lager. När du ändrar en avbildning, till exempel uppdaterar en applikation, skapas ett nytt lager. Så, utan att ersätta hela avbildningen eller bygga om den, som du kanske behöver göra med en virtuell maskin, läggs endast lagret till eller uppdateras. Och du behöver inte distribuera hela den nya avbildningen, endast uppdateringen delas ut, vilket gör att avbildningar kan distribueras enklare och snabbare.

I grunden för varje bild finns en basbild. Till exempel, ubuntu, basbilden för Ubuntu, eller fedora, basbilden för Fedora-distributionen. Du kan också använda bilder som bas för att skapa nya bilder. Till exempel, om du har en bild av apache, kan du använda den som basbild för dina webbapplikationer.

Notera! Docker hämtar vanligtvis bilder från Docker Hub-registret.

Dockerbilder kan skapas från dessa basbilder, stegen för att skapa dessa bilder kallar vi instruktioner. Varje instruktion skapar en ny bild eller nivå. Instruktionerna kommer att vara följande åtgärder:

• körning av kommando
• tillägg av fil eller katalog
• skapa en omgivningsvariabel
• ange vad som ska köras när den här bildens container startas

Dessa instruktioner lagras i en fil Dockerfile. Docker läser detta Dockerfile, när du bygger bilden, utför dessa instruktioner, och returnerar den slutliga bilden.

Hur fungerar docker-registret?

Registret är ett förråd av dockerbilder. Efter att ha skapat en bild kan du publicera den på det offentliga registret Docker Hub eller på ditt eget personliga register.

Med hjälp av dockerklienten kan du söka efter redan publicerade bilder och ladda ner dem till din maskin med docker för att skapa containrar.

Docker Hub erbjuder offentliga och privata förråd av bilder. Sökning och nedladdning av bilder från offentliga förråd är tillgänglig för alla. Innehållet i privata förråd syns inte i sökresultaten. Endast du och dina användare kan hämta dessa bilder och skapa containrar från dem.

Hur fungerar en container?

En container består av ett operativsystem, användarfiler och metadata. Som vi vet, skapas varje container från en bild. Denna bild talar om för docker vad som finns i containern, vilken process som ska startas när containern startas och annan konfigurationsdata. Dockerbilden är skrivskyddad. När docker startar en container, skapar den ett lager för läsning/skrivning ovanpå bilden (använder en union filsystem, som nämnts tidigare), där en applikation kan köras.

Vad händer när en container startas?

Antingen med hjälp av programmet docker, eller genom RESTful API, säger dockerklienten till docker-demonen att starta containern.

$ sudo docker run -i -t ubuntu /bin/bash

Låt oss reda ut denna kommando. Klienten startar med kommandot docker, med alternativet run, som anger att en ny container kommer att startas. Minimi krav för att starta containern är följande attribut:

• vilken bild som ska användas för att skapa containern. I vårt fall ubuntu
• kommandot som du vill köra när containern startas. I vårt fall /bin/bash

Vad händer egentligen bakom kulisserna när vi kör detta kommando?

Docker gör följande i ordning:

• laddar ner bild av ubuntu: docker kontrollerar om bilden finns ubuntu på den lokala maskinen, och om den inte finns — laddar ner den från Docker Hub. Om bilden redan finns, används den för att skapa containern;
• skapar containern: när bilden har mottagits, använder docker den för att skapa containern;
• initialiserar filsystemet och monterar read-only nivån: containern skapas i filsystemet och read-only nivån läggs till bilden;
• initialiserar nätverket/bro: skapar ett nätverksgränssnitt som tillåter docker att kommunicera med värdmaskinen;
• Sätter IP-adress: hittar och anger adress;
• Startar angiven process: startar din applikation;
• Behandlar och ger utdata från din applikation: ansluter och loggar standardin, ut och felström från din applikation så att du kan övervaka hur din applikation fungerar.

Nu har du en fungerande container. Du kan hantera din container, interagera med din applikation. När du vill stoppa applikationen, ta bort containern.

Använda teknologier

Docker är skrivet i Go och använder vissa funktioner från Linux-kärnan för att implementera ovanstående funktionalitet.

Namnrymder (namespaces)

Docker använder teknologin namnrymder för att organisera isolerade arbetsytor, som vi kallar containrar. När vi startar en container skapar docker en uppsättning namnrymder för den containern.

Detta skapar en isolerad nivå, varje aspekt av containern körs i sin egen namnrymd och har inte tillgång till det externa systemet.

Lista över några namnrymder som docker använder:

• pid: för isolering av processen;
• net: för att hantera nätverksgränssnitt;
• ipc: för att hantera IPC-resurser. (ICP: InterProccess Communication);
• mnt: för att hantera monteringspunkter;
• utc: för isolering av kärnan och kontroll av versionsgenerering (UTC: Unix time-sharing system).

Kontrollgrupper (Control groups)

Docker använder också teknologin cgroups eller kontrollgrupper. Nyckeln till att köra applikationen i isolering är att endast tillhandahålla applikationen de resurser som du vill ge. Detta säkerställer att containrarna är bra grannar. Kontrollgrupper möjliggör fördelning av tillgängliga hårdvaruresurser och kan om så behövs ställa in gränser och begränsningar. Till exempel, begränsa den möjliga mängden minne för en container.

Union File System

Union File System eller UnionFS är ett filsystem som fungerar genom att skapa lager, vilket gör det mycket lätt och snabbt. Docker använder UnionFS för att skapa block som en container byggs av. Docker kan använda flera varianter av UnionFS inklusive: AUFS, btrfs, vfs och DeviceMapper.

Containerformat

Docker kombinerar dessa komponenter i ett omslag som vi kallar containerformat. Formatet som används som standard kallas libcontainer. Docker stöder också det traditionella containerformatet i Linux via LXC. I framtiden kan Docker komma att stödja andra containerformat. Till exempel, genom att integrera med BSD Jails eller Solaris Zones.

Källa: habr.com