På CoreOS, ställ in ditt eget Docker-register

Vi känner alla till och älskar Docker, en plattform för att skapa, hantera och distribuera applikationsbehållare över flera maskiner. Docker Inc. tillhandahåller en tjänst för behållare med öppen källkod som ska laddas ner (eller dras) som ett git-förråd känt som "Docker Registry". Tänk på det som en GitHub för Docker-behållare.

Men vad händer om du vill ha ditt eget register skilt från det offentliga? Nåväl, Docker Inc. har öppen källkod för sin registerapplikation på GitHub.

Denna handledning tar dig igenom processen att ställa in ett privat Docker-register med CoreOS på en ny VPS.

CoreOS + Docker

Vi kommer inte att spendera massor av tid på att gå igenom exakt vad Docker och CoreOS kan göra, eftersom det ligger utanför ramen för denna handledning. I huvudsak är CoreOS designat för massiva serverkluster, det är litet, snabbt och får regelbundna säkerhetsuppdateringar automatiskt. Dess rotfilsystem är också skrivskyddat, vilket innebär att du måste använda Docker för att köra någon form av programvara som inte ingår i basinstallationen.

Detta gör Core OS till ett perfekt värdsystem för Docker!

Hämta och köra det senaste registret

Docker Inc. har tillhandahållit registret som en toppnivåbild, detta betyder att vi kan dra ner den med en enkel:

docker pull registry

This can take a few minutes depending on the connection speed.

Ett plus med att vara en bild på toppnivå innebär också att den får regelbunden support och uppdateringar.

Låt oss nu testa registret. Vi kan skapa en ny behållare med hjälp av registeravbildningen:

docker run -p 5000:5000 -d --name=basic_registry registry

För de som inte har använt Docker för mycket -pstår flaggan för PORT, vilket betyder att vi exponerar port 5000 på från containern till värdport 5000.

Den -dFlaggan står för daemon, kommer detta att leda till behållaren för att köra i bakgrunden och inte skriva ut till den nuvarande SSH-session, vill vi nämna denna grundläggande testbehållare med hjälp av --namealternativet så att vi enkelt kan hantera det senare.

Se till att din grundläggande registerbehållare körs med docker ps. Utgången ska se ut som:

CONTAINER ID        IMAGE               COMMAND                CREATED             STATUS              PORTS                    NAMES
edfb54e4a8c4        registry:0.8.1      "/bin/sh -c 'exec do   7 seconds ago       Up 6 seconds        0.0.0.0:5000->5000/tcp   basic_registry

Besök även http://YOUR_IP:5000i din webbläsare och du bör få ett meddelande som följande:

"docker-registry server (dev) (v0.8.1)"

Notice the word dev in the parenthesis. This means that the server is currently running the dev config. We'll look over more configuration soon.

Du har nu ditt eget (mycket grundläggande) containerregister igång! Men vi är inte klara än.

Kanske vill du hålla detta privat från nyfikna ögon, eller kanske lagra dina bilder på Amazon S3 istället för lokal lagring. Låt oss gå igenom de olika konfigurationsalternativen i nästa avsnitt.

Innan vi går vidare, låt oss döda testbehållaren så att vi inte stöter på motstridiga hamnar.

docker kill basic_registry

Registerkonfiguration

Det finns två sätt som vi kan skicka konfiguration till Docker Registry. Ett sätt är att skicka miljövariabler till en ny behållare, och det andra är att lägga till en konfigurationsfil.

Här är några av de vanliga konfigurationsalternativen vi kommer att använda:

• loglevel- Minsta mängd information för att logga till konsolen. Standard är info.
• standalone- Bör det här registret agera på egen hand? (Frågor aldrig det offentliga registret.) Standard är true.
• index_endpoint- Om inte fristående, vilket annat index kommer vi att fråga? Standard index.docker.io.
• cacheoch cache_lru- Alternativ för att använda en Redis-cache för små filer, vi kommer att beröra detta senare.
• storage- Vilken lagringsbackend ska vi använda för den här servern? (I den här handledningen kommer vi att använda lokalt).
• storage_path - Om vi ​​använder lokal lagring, vilken katalog ska vi använda för att lagra filer i?

Innan vi börjar arbeta med konfigurationen behöver vi en basfil att arbeta med. Filen från Docker Registry-förvaret på GitHub kommer att fungera bra:

wget https://raw.githubusercontent.com/docker/docker-registry/0.8/config/config_sample.yml

Filen bör sparas framgångsrikt med en utdata som:

2014-09-14 14:09:01 (156 MB/s) - 'config_sample.yml' saved [5384/5384]

Bra! Nu kan vi ändra den här filen så att den passar våra behov.

Den enda textredigeraren som kommer med Core OS är vim, men oroa dig inte om du aldrig har använt den förut, detta kommer att förklara steg för steg vad du ska redigera och hur du gör det.

vim config_sample.yml

När du har öppnat filen, tryck på Ioch det nedre högra hörnet ska visas: -- INSERT --för infogningsläge. Bläddra hela vägen till botten av filen med hjälp av piltangenterna, du bör se ett avsnitt märkt prod.

Vi kommer att ändra de två raderna, ändringarna finns nedan

prod:
    <<: *local
    storage_path: _env:STORAGE_PATH:/data

Vad vi har gjort är att ändra prodkonfigurationen så att den kommer från localavsnittet istället för s3avsnittet. Sedan skrev vi över för storage_pathatt använda vägen /datainuti den nya behållaren.

När du har bekräftat att alla ändringar är korrekta, tryck för ESCatt avsluta infogningsläget och skriv :wq(detta betyder att du skriver ändringarna i filen och avslutar vim.)

Låt oss nu byta namn på filen till bara config.yml

mv config_sample.yml config.yml

Redis cachning (valfritt)

Om du vill använda redis för att snabba upp ditt containerregister är det så enkelt som att hämta en ny container från det offentliga registret och lägga till några fler konfigurationsrader.

Dra först den översta bilden av Redis:

docker pull redis

När bilden väl har hämtats kan vi köra den och namnge den precis som vi gjorde med testregistret:

docker run -d --name registry-redis redis

Eftersom redis finns i minnet behöver vi inte göra någon konfiguration för det, eftersom vi kommer att länka det till registerbehållaren i senare steg.

Återigen, se till att den körs genom att använda docker ps:

CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS               NAMES
54f65641eccf        redis:2.8           "redis-server"      2 seconds ago       Up 1 seconds        6379/tcp            registry-redis

Nu åter öppna config.ymli vimoch anger infogningsläget precis som första gången vi redigerade det.

Lägg till följande rader under prodavsnittet, var noga med att dra in ordentligt. Den här gången lägger vi bara till cacheoch cache_lru.

cache:
    host: _env:REDIS_PORT_6379_TCP_ADDR
    port: _env:REDIS_PORT_6379_TCP_PORT
    db: 0

cache_lru:
    host: _env:REDIS_PORT_6379_TCP_ADDR
    port: _env:REDIS_PORT_6379_TCP_PORT
    db: 1

Miljövariablerna REDIS_PORT_6379_TCP_ADDRoch REDIS_PORT_6379_TCP_PORTskickas till registerbehållaren vid länkning med Redis-behållaren.

Med det har du nu ställt in en Redis-behållare som kommer att fungera hand i hand med din registerbehållare. Nu på att bygga registret!

Bygga containern

Vi har all konfiguration inställd och klar, nu måste vi bygga den faktiska registerbehållaren.

Starta för vim Dockerfileatt skapa en ny Dockerfile. Gå in i infogningsläge och följ redigeringarna nedan.

FROM registry:latest

# Add the custom configuration file we made 
ADD ./config.yml /docker-registry/config/config.yml

# Create the data directory
RUN mkdir /data

# Set the configuration file to config.yml
env DOCKER_REGISTRY_CONFIG /docker-registry/config/config.yml

# Make sure we use the prod configuration settings 
env SETTINGS_FLAVOR prod

Vad vi har gjort ovan är i huvudsak att utöka registerbilden så att den kommer att använda vår konfigurationsfil och inställningar. En Dockerfil är en uppsättning bygginstruktioner för Docker att läsa och bygga. Om du vill lära dig mer om Dockerfiler och deras syntax, ta en titt på den officiella dokumentationen för Docker-webbplatsen.

Därefter måste vi bygga behållaren för användning.

docker build -t my_registry .


Sending build context to Docker daemon 13.82 kB
Sending build context to Docker daemon 
Step 0 : FROM registry
 ---> e42d15ec8417
Step 1 : ADD ./config.yml /docker-registry/config/config.yml
 ---> 4339f026d459
Removing intermediate container 2d5138fbcd34
Step 2 : RUN mkdir /data
 ---> Running in a090f0bdbfd1
 ---> 8eb27ba6e12a
Removing intermediate container a090f0bdbfd1
Step 3 : env DOCKER_REGISTRY_CONFIG /docker-registry/config/config.yml
 ---> Running in 565b5bfb2b22
 ---> 914462e46dc0
Removing intermediate container 565b5bfb2b22
Step 4 : env SETTINGS_FLAVOR prod
 ---> Running in 31a92847b851
 ---> b5949575c374
Removing intermediate container 31a92847b851
Successfully built b5949575c374

Nu är vi redo att springa!

Låt oss skapa en katalog på vårt värdsystem för att montera i behållaren som /datavolym.

mkdir registry-data

Nu kan vi snurra upp en ny container. Om du planerar att använda Redis-cachen, använd det andra kommandot nedan.

# For a non-Redis cache registry
docker run -d -p 5000:5000 -v /home/core/registry-data:/data --name=private_reg my_registry

# For a Redis cached registry (Must have followed Redis Caching section above)
docker run -d -p 5000:5000 -v /home/core/registry-data:/data --name=private_reg --link registry-redis:redis my_registry

För att säkerställa att din server fungerar korrekt, besök http://YOUR_IP:5000. Du kommer att se följande meddelande:

"docker-registry server (prod) (v0.8.1)"

Lägg märke till (prod)betydelsen av att våra konfigurationsändringar var framgångsrika!

Konfigurera din lokala Docker-klient

Nu när vi har ett eget körregister vill vi att Docker-klienten på våra lokala maskiner ska börja använda det. Vanligtvis skulle du använda kommandot: docker login, men för vår användning måste vi lägga till ytterligare ett argument till inloggningskommandot:

docker login YOUR_IP:5000

Ange ett användarnamn och lösenord (tänk på det här som att skapa ett nytt konto) och ignorera meddelandet som säger att du måste aktivera det.

Låt oss sedan dra en stockbild och skjuta upp den till vårt eget arkiv.

# Pull the busybox image from the public registry
docker pull busybox

# Tag it with our IP/URL
docker tag busybox YOUR_IP:5000/busybox

# Push it to our newly made registry
docker push YOUR_IP:5000/busybox

Om allt trycker på korrekt bör det slutliga meddelandet vara i stil med:

Pushing tag for rev [a9eb17255234] on 

Grattis! Du har ställt in ditt eget docker-förråd.

Vad kommer härnäst?

Här är några idéer om hur du kan förbättra ditt nya privata register:

• Omvänd proxy med Nginx eller Apache för att placera ytterligare säkerhet framför den, som enkel HTTP-autentisering.
• Skaffa en domän för din server och konfigurera den så att du kan komma åt ditt register med något som: registry.mysite.com
• Köp (eller självsignera) ett SSL-certifikat för att lägga till ännu mer skydd om dina behållare innehåller känslig information.