Stel op CoreOS uw eigen Docker-register in

• CoreOS + Docker
• Het nieuwste register ophalen en uitvoeren
• Registerconfiguratie
• Redis caching (optioneel)
• De container bouwen
• Configureer uw lokale Docker-client
• Wat is het volgende?

We kennen en houden allemaal van Docker, een platform voor het maken, beheren en distribueren van applicatiecontainers over meerdere machines. Docker Inc. biedt een service voor het hosten van open source-containers die kunnen worden gedownload (of opgehaald) als een git-opslagplaats die bekend staat als het "Docker-register". Zie het als een GitHub voor Docker-containers.

Maar wat als u uw eigen register gescheiden van het openbare wilt hosten? Welnu, Docker Inc. heeft hun registertoepassing op GitHub open source gemaakt.

Deze tutorial neemt je mee door het proces van het opzetten van een privé Docker-register met CoreOS op een nieuwe VPS.

CoreOS + Docker

We zullen niet veel tijd besteden aan het bespreken van precies wat Docker en CoreOS kunnen doen, omdat het buiten het bestek van deze tutorial valt. In wezen is CoreOS ontworpen voor enorme serverclusters, het is klein, snel en krijgt automatisch automatische beveiligingsupdates. Het rootbestandssysteem is ook alleen-lezen, wat betekent dat u Docker moet gebruiken om alle soorten software uit te voeren die niet bij de basisinstallatie zijn inbegrepen.

Dit maakt Core OS een perfect hostsysteem voor Docker!

Het nieuwste register ophalen en uitvoeren

Docker Inc. heeft het register als een image op het hoogste niveau geleverd, wat betekent dat we het naar beneden kunnen halen met een simpele:

docker pull registry

Dit kan enkele minuten duren, afhankelijk van de verbindingssnelheid.

Een pluspunt van het zijn van een afbeelding op het hoogste niveau betekent ook dat het regelmatig ondersteuning en updates krijgt.

Laten we nu het register testen. We kunnen een nieuwe container maken met behulp van de registerimage:

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

Voor degenen die Docker niet te veel hebben gebruikt, staat de -pvlag voor PORT, wat betekent dat we poort 5000 vanaf de container blootstellen aan hostpoort 5000.

De -dvlag staat voor daemon, hierdoor wordt de container op de achtergrond uitgevoerd en wordt geen uitvoer naar de huidige SSH-sessie afgedrukt, we willen deze basistestcontainer ook een naam geven met de --nameoptie, zodat we deze later gemakkelijk kunnen beheren.

Zorg ervoor dat uw standaard registercontainer wordt uitgevoerd met docker ps. De uitvoer moet er ongeveer zo uitzien:

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

Bezoek ook http://YOUR_IP:5000in uw webbrowser en u zou een bericht als het volgende moeten krijgen:

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

Let op het woord devtussen haakjes. Dit betekent dat de server momenteel de dev-configuratie uitvoert. We zullen binnenkort meer configuratie bekijken.

U heeft nu uw eigen (zeer eenvoudige) containerregister! Maar we zijn nog niet klaar.

Misschien wil je dit privé houden voor nieuwsgierige blikken, of misschien je afbeeldingen opslaan op Amazon S3 in plaats van lokale opslag. Laten we de verschillende configuratie-opties in de volgende sectie bespreken.

Voordat we verder gaan, laten we de testcontainer doden zodat we geen tegenstrijdige poorten tegenkomen.

docker kill basic_registry

Registerconfiguratie

Er zijn twee manieren waarop we de configuratie kunnen doorgeven aan het Docker-register. De ene manier is om omgevingsvariabelen door te geven aan een nieuwe container en de andere is om een ​​configuratiebestand toe te voegen.

Hier zijn enkele van de algemene configuratie-opties die we zullen gebruiken:

• loglevel- De minimale hoeveelheid informatie om in te loggen op de console. Standaard is info.
• standalone- Moet dit register zelfstandig handelen? (Nooit vragen stellen aan het openbare register.) Standaard is true.
• index_endpoint- Indien niet op zichzelf staand, welke andere index zullen we dan opvragen? Standaard index.docker.io.
• cacheen cache_lru- Opties met betrekking tot het gebruik van een Redis-cache voor kleine bestanden, we komen hier later op terug.
• storage- Welke storage-backend moeten we gebruiken voor deze server? (In deze tutorial gebruiken we lokaal).
• storage_path - Als we lokale opslag gebruiken, welke map moeten we dan gebruiken om bestanden in te bewaren?

Voordat we met de configuratie aan de slag gaan, hebben we een basisbestand nodig om mee te werken. Het bestand uit de Docker Registry-repository op GitHub werkt prima:

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

Het bestand moet met succes worden opgeslagen met een uitvoer zoals:

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

Super goed! Nu kunnen we dit bestand aanpassen aan onze behoeften.

De enige teksteditor die bij Core OS wordt geleverd vim, is , maar maak je geen zorgen als je het nog nooit eerder hebt gebruikt, dit zal stap voor stap uitleggen wat je moet bewerken en hoe je het moet doen.

vim config_sample.yml

Zodra je het bestand hebt geopend, druk je op de Ien de rechter benedenhoek zou moeten verschijnen: -- INSERT --voor invoegmodus. Scrol helemaal naar de onderkant van het bestand met je pijltjestoetsen, je zou een sectie met het label moeten zien prod.

We gaan de twee regels wijzigen, de wijzigingen staan ​​hieronder

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

Wat we hebben gedaan, is de prodconfiguratie wijzigen om af te leiden van de localsectie in plaats van de s3sectie. Vervolgens hebben we de overschreven storage_pathom het pad /datain de nieuwe container te gebruiken.

Zodra je hebt bevestigd dat alle wijzigingen correct zijn, druk je op ESCom de invoegmodus te verlaten en te typen :wq(dit betekent dat je de wijzigingen naar het bestand schrijft en vim afsluit).

Laten we het bestand nu hernoemen naar gewoon config.yml

mv config_sample.yml config.yml

Redis caching (optioneel)

Als u redis wilt gebruiken om uw containerregister te versnellen, is dat net zo eenvoudig als het trekken van een nieuwe container uit het openbare register en het toevoegen van nog enkele configuratielijnen.

Trek eerst de afbeelding van Redis op het hoogste niveau:

docker pull redis

Zodra de afbeelding met succes is opgehaald, kunnen we deze uitvoeren en een naam geven zoals we deden met het testregister:

docker run -d --name registry-redis redis

Omdat redis in het geheugen zit, hoeven we er geen configuratie voor te doen, omdat we het in latere stappen aan de registercontainer zullen koppelen.

Zorg er nogmaals voor dat het actief is met behulp van 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

Open nu de config.ymlin vimen voer de invoegmodus in, net als de eerste keer dat we het hebben bewerkt.

Voeg de volgende regels toe onder de prodsectie en zorg ervoor dat u goed inspringt. Deze keer voegen we alleen cacheen toe 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

De omgevingsvariabelen REDIS_PORT_6379_TCP_ADDRen REDIS_PORT_6379_TCP_PORTworden doorgegeven aan de registercontainer bij koppeling met de Redis-container.

Daarmee heeft u nu een Redis-container ingesteld die hand in hand zal werken met uw registercontainer. Nu verder met het bouwen van het register!

De container bouwen

We hebben alle configuratie ingesteld en klaar, nu moeten we de eigenlijke registercontainer bouwen.

Vuur van vim Dockerfileeen nieuwe Dockerfile creëren. Ga naar de invoegmodus en volg de onderstaande bewerkingen.

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

Wat we hierboven hebben gedaan, is in wezen de registerimage uitbreiden, zodat deze ons configuratiebestand en onze instellingen zal gebruiken. Een Dockerfile is een set bouwinstructies die Docker moet lezen en bouwen. Als je meer wilt weten over Dockerfiles en hun syntaxis, bekijk dan de officiële Docker-sitedocumentatie.

Vervolgens moeten we de container bouwen voor gebruik.

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 zijn we klaar om te rennen!

Laten we een directory maken op ons hostsysteem om als /datavolume in de container te mounten .

mkdir registry-data

Nu kunnen we een nieuwe container laten draaien. Als u van plan bent de Redis-cache te gebruiken, gebruikt u de 2e opdracht hieronder.

# 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

Ga naar om te controleren of uw server correct werkt http://YOUR_IP:5000. Je ziet het volgende bericht:

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

Let op de (prod)betekenis dat onze configuratiewijzigingen succesvol waren!

Configureer uw lokale Docker-client

Nu we ons eigen register hebben, willen we dat de Docker-client op onze lokale machines deze gaat gebruiken. Normaal gesproken gebruikt u het commando:, docker loginmaar voor ons gebruik moeten we nog een argument toevoegen aan het login-commando:

docker login YOUR_IP:5000

Voer een gebruikersnaam en wachtwoord in (denk hierbij aan het maken van een nieuw account) en negeer het bericht dat u deze moet activeren.

Laten we vervolgens een voorraadafbeelding trekken en deze naar onze eigen repository pushen.

# 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

Als alles correct wordt gepusht, zou het laatste bericht moeten zijn in de trant van:

Pushing tag for rev [a9eb17255234] on 

Gefeliciteerd! Je hebt je eigen docker-repository opgezet.

Wat is het volgende?

Hier zijn enkele ideeën over hoe u uw nieuwe privé-register kunt verbeteren:

• Omgekeerde proxy met Nginx of Apache om er extra beveiliging voor te plaatsen, zoals eenvoudige HTTP-verificatie.
• Koop een domein voor uw server en stel het in zodat u toegang heeft tot uw register met zoiets als: registry.mysite.com
• Koop (of onderteken zelf) een SSL-certificaat om nog meer bescherming toe te voegen als uw containers gevoelige informatie bevatten.