GNU/Linux >> Znalost Linux > >> Panels >> Docker

Jak nasadit mikroslužby s Dockerem

<šablona x-if=visible><šablona x-if=$isMobile()>

Co je to mikroslužba?

Mikroslužby jsou stále populárnější architekturou pro vytváření rozsáhlých aplikací. Namísto použití jediné, monolitické kódové základny jsou aplikace rozděleny do kolekce menších komponent nazývaných mikroslužby. Tento přístup nabízí několik výhod, včetně možnosti škálovat jednotlivé mikroslužby, udržovat kódovou základnu srozumitelnější a testovatelnou a umožňuje použití různých programovacích jazyků, databází a dalších nástrojů pro každou mikroslužbu.

Docker je vynikající nástroj pro správu a nasazení mikroslužeb. Každou mikroslužbu lze dále rozdělit na procesy běžící v samostatných kontejnerech Docker, které lze specifikovat pomocí konfiguračních souborů Dockerfiles a Docker Compose. V kombinaci s nástrojem pro zřizování, jako je Kubernetes, lze pak každou mikroslužbu snadno nasadit, škálovat a spolupracovat na ní vývojářský tým. Specifikace prostředí tímto způsobem také usnadňuje propojení mikroslužeb a vytvoření větší aplikace.

Tato příručka ukazuje, jak vytvořit a nasadit ukázkovou mikroslužbu pomocí Docker a Docker Compose.

Než začnete

Pokud jste tak ještě neučinili, vytvořte si účet Linode a Compute Instance. Podívejte se na naše příručky Začínáme s Linode a Vytvoření výpočetní instance.
Při aktualizaci systému postupujte podle našeho průvodce nastavením a zabezpečením výpočetní instance. Můžete také chtít nastavit časové pásmo, nakonfigurovat název hostitele, vytvořit omezený uživatelský účet a posílit přístup SSH.

Poznámka Tato příručka je napsána pro uživatele bez oprávnění root. Příkazy, které vyžadují zvýšená oprávnění, mají předponu sudo . Pokud neznáte sudo můžete se podívat na naši příručku Uživatelé a skupiny.

Instalovat Docker

Chcete-li nainstalovat Docker CE (Community Edition), postupujte podle pokynů v jedné z níže uvedených příruček:

Instalace a používání Dockeru na Ubuntu a Debian
Instalace a používání Dockeru na CentOS a Fedoře

Úplné pokyny pro ještě více distribucí Linuxu naleznete v části Instalace Docker Engine v oficiální dokumentaci Dockeru.

Instalovat Docker Compose

Stáhněte si nejnovější verzi Docker Compose. Zkontrolujte stránku s vydáními a nahraďte 1.25.4 v příkazu níže s verzí označenou jako Poslední vydání :
```
 sudo curl -L https://github.com/docker/compose/releases/download/1.25.4/docker-compose-`uname -s`-`uname -m` -o /usr/local/bin/docker-compose
```

Nastavit oprávnění souboru:

 sudo chmod +x /usr/local/bin/docker-compose

Připravte prostředí

Tato část používá soubory Docker ke konfiguraci obrazů Docker. Další informace o syntaxi a osvědčených postupech Dockerfile naleznete v naší příručce Jak používat Dockerfiles a v příručce Docker'sDockerfile Best Practices.

Vytvořte adresář pro mikroslužbu:
```
 mkdir flask-microservice
```
Vytvořte adresářovou strukturu pro komponenty mikroslužeb v rámci nového adresáře:
```
 cd flask-microservice
 mkdir nginx postgres web
```

NGINX

V rámci nového nginx podadresář, vytvořte Dockerfile pro obraz NGINX:
Soubor:nginx /Dockerfile
1 2

from nginx:alpine COPY nginx.conf /etc/nginx/nginx.conf

Vytvořte nginx.conf odkazovaný v Dockerfile:

Soubor:/ nginx/nginx.conf

user  nginx;
worker_processes 1;
error_log  /dev/stdout info;
error_log off;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
    use epoll;
    multi_accept on;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';

    access_log  /dev/stdout main;
    access_log off;
    keepalive_timeout 65;
    keepalive_requests 100000;
    tcp_nopush on;
    tcp_nodelay on;

    server {
        listen 80;
        proxy_pass_header Server;

        location / {
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;

            # app comes from /etc/hosts, Docker added it for us!
            proxy_pass http://flaskapp:8000/;
        }
    }
}

PostgreSQL

Obraz PostgreSQL pro tuto mikroslužbu bude používat oficiální postgresql image na Docker Hub, takže není potřeba žádný Dockerfile.

V postgres podadresář, vytvořte init.sql soubor:

Soubor:postgres /init.sql

SET statement_timeout = 0;
SET lock_timeout = 0;
SET idle_in_transaction_session_timeout = 0;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET client_min_messages = warning;
SET row_security = off;
CREATE EXTENSION IF NOT EXISTS plpgsql WITH SCHEMA pg_catalog;
COMMENT ON EXTENSION plpgsql IS 'PL/pgSQL procedural language';
SET search_path = public, pg_catalog;
SET default_tablespace = '';
SET default_with_oids = false;
CREATE TABLE visitors (
    site_id integer,
    site_name text,
    visitor_count integer
);

ALTER TABLE visitors OWNER TO postgres;
COPY visitors (site_id, site_name, visitor_count) FROM stdin;
1 	linodeexample.com  	0
\.

Pozor Na řádku 22 souboru init.sql , ujistěte se, že váš textový editor nepřevádí tabulátory na mezery. Aplikace nebude fungovat bez tabulátorů mezi položkami v tomto řádku.

Web

web obrázek bude obsahovat příklad aplikace Flask. Přidejte na web následující soubory adresář pro přípravu aplikace:

Vytvořte .python-version soubor k určení použití Pythonu 3.6:
```
 echo "3.6.0" >> web/.python-version
```

Vytvořte Dockerfile pro web obrázek:

Soubor:web /Dockerfile

from python:3.6.2-slim
RUN groupadd flaskgroup && useradd -m -g flaskgroup -s /bin/bash flask
RUN echo "flask ALL=(ALL) NOPASSWD:ALL" >> /etc/sudoers
RUN mkdir -p /home/flask/app/web
WORKDIR /home/flask/app/web
COPY requirements.txt /home/flask/app/web
RUN pip install --no-cache-dir -r requirements.txt
RUN chown -R flask:flaskgroup /home/flask
USER flask
ENTRYPOINT ["/usr/local/bin/gunicorn", "--bind", ":8000", "linode:app", "--reload", "--workers", "16"]

Vytvořte web/linode.py a přidejte ukázkový skript aplikace:

Soubor:web /linode.py

from flask import Flask
import logging
import psycopg2
import redis
import sys

app = Flask(__name__)
cache = redis.StrictRedis(host='redis', port=6379)

# Configure Logging
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.DEBUG)

def PgFetch(query, method):

    # Connect to an existing database
    conn = psycopg2.connect("host='postgres' dbname='linode' user='postgres' password='linode123'")

    # Open a cursor to perform database operations
    cur = conn.cursor()

    # Query the database and obtain data as Python objects
    dbquery = cur.execute(query)

    if method == 'GET':
        result = cur.fetchone()
    else:
        result = ""

    # Make the changes to the database persistent
    conn.commit()

    # Close communication with the database
    cur.close()
    conn.close()
    return result

@app.route('/')
def hello_world():
    if cache.exists('visitor_count'):
        cache.incr('visitor_count')
        count = (cache.get('visitor_count')).decode('utf-8')
        update = PgFetch("UPDATE visitors set visitor_count = " + count + " where site_id = 1;", "POST")
    else:
        cache_refresh = PgFetch("SELECT visitor_count FROM visitors where site_id = 1;", "GET")
        count = int(cache_refresh[0])
        cache.set('visitor_count', count)
        cache.incr('visitor_count')
        count = (cache.get('visitor_count')).decode('utf-8')
    return 'Hello Linode!  This page has been viewed %s time(s).' % count

@app.route('/resetcounter')
def resetcounter():
    cache.delete('visitor_count')
    PgFetch("UPDATE visitors set visitor_count = 0 where site_id = 1;", "POST")
    app.logger.debug("reset visitor count")
    return "Successfully deleted redis and postgres counters"

Přidejte requirements.txt soubor s požadovanými závislostmi Pythonu:
Soubor:web /requirements.txt
1 2 3 4

flask gunicorn psycopg2-binary redis

Docker Compose

Docker Compose bude použit k definování spojení mezi kontejnery a jejich konfiguračním nastavením.

Vytvořte docker-compose.yml soubor v flask-microservice adresář a přidejte následující:

Soubor:docker -compose.yml

version: '3'
services:
 # Define the Flask web application
 flaskapp:

   # Build the Dockerfile that is in the web directory
   build: ./web

   # Always restart the container regardless of the exit status; try and restart the container indefinitely
   restart: always

   # Expose port 8000 to other containers (not to the host of the machine)
   expose:
     - "8000"

   # Mount the web directory within the container at /home/flask/app/web
   volumes:
     - ./web:/home/flask/app/web

   # Don't create this container until the redis and postgres containers (below) have been created
   depends_on:
     - redis
     - postgres

   # Link the redis and postgres containers together so they can talk to one another
   links:
     - redis
     - postgres

   # Pass environment variables to the flask container (this debug level lets you see more useful information)
   environment:
     FLASK_DEBUG: 1

   # Deploy with three replicas in the case one of the containers fails (only in Docker Swarm)
   deploy:
     mode: replicated
     replicas: 3

 # Define the redis Docker container
 redis:

   # use the redis:alpine image: https://hub.docker.com/_/redis/
   image: redis:alpine
   restart: always
   deploy:
     mode: replicated
     replicas: 3

 # Define the redis NGINX forward proxy container
 nginx:

   # build the nginx Dockerfile: http://bit.ly/2kuYaIv
   build: nginx/
   restart: always

   # Expose port 80 to the host machine
   ports:
     - "80:80"
   deploy:
     mode: replicated
     replicas: 3

   # The Flask application needs to be available for NGINX to make successful proxy requests
   depends_on:
     - flaskapp

 # Define the postgres database
 postgres:
   restart: always
   # Use the postgres alpine image: https://hub.docker.com/_/postgres/
   image: postgres:alpine

   # Mount an initialization script and the persistent postgresql data volume
   volumes:
     - ./postgres/init.sql:/docker-entrypoint-initdb.d/init.sql
     - ./postgres/data:/var/lib/postgresql/data

   # Pass postgres environment variables
   environment:
     POSTGRES_PASSWORD: linode123
     POSTGRES_DB: linode

   # Expose port 5432 to other Docker containers
   expose:
     - "5432"

Otestujte mikroslužbu

Pomocí Docker Compose vytvořte všechny obrázky a spusťte mikroslužbu:
```
cd flask-microservice/ && docker-compose up
```
Měli byste vidět, že všechny služby začínají ve vašem terminálu.
Otevřete nové okno terminálu a odešlete požadavek na ukázkovou aplikaci:
```
curl localhost
```
```
Hello Linode! This page has been viewed 1 time(s).
```

Vynulujte počítadlo přístupů na stránku:

curl localhost/resetcounter

Successfully deleted redis and postgres counters

Vraťte se do okna terminálu, kde byl spuštěn Docker Compose, a prohlédněte si standardní protokol odhlášení:
```
flaskapp_1  | DEBUG in linode [/home/flask/app/web/linode.py:56]:
flaskapp_1  | reset visitor count
```

Používání kontejnerů v produkci:Nejlepší postupy

Kontejnery použité v ukázkové mikroslužbě mají demonstrovat následující osvědčené postupy pro používání kontejnerů v produkci:

Kontejnery by měly být:

Prchavé :Mělo by být snadné zastavit, zničit, znovu postavit a znovu nasadit kontejnery s minimálním nastavením a konfigurací.

Mikroslužba Flask je toho ideálním příkladem. Celou mikroslužbu lze posunout nahoru nebo dolů pomocí Docker Compose. Po spuštění kontejnerů není nutná žádná další konfigurace, což usnadňuje úpravu aplikace.
Jednorázové :V ideálním případě by každý jednotlivý kontejner v rámci větší aplikace měl být schopen selhat bez dopadu na výkon aplikace. Pomocí restart: on-failure možnost v docker-compose.yml soubor, stejně jako počet replik, umožňuje, aby některé kontejnery v ukázkové mikroslužbě bez problémů selhaly, zatímco stále obsluhují webovou aplikaci – bez snížení kvality pro koncového uživatele.

Poznámka Direktiva počtu replik bude účinná pouze tehdy, když je tato konfigurace nasazena jako součást aDocker Swarm, která není zahrnuta v této příručce.
Rychlý začátek :Vyhýbání se dalším krokům instalace v souboru Docker, odstranění závislostí, které nejsou potřeba, a vytvoření cílové bitové kopie, kterou lze znovu použít, jsou tři nejdůležitější kroky při vytváření webové aplikace, která má v rámci Dockeru rychlou inicializaci. Ukázková aplikace používá krátké, stručné, předem vytvořené soubory Dockerfiles, aby se minimalizovala doba inicializace.
Rychle zastavit :Ověřte, že docker kill --signal=SIGINT {APPNAME} ladně zastaví aplikaci. To spolu s podmínkou restartu a podmínkou repliky zajistí, že když kontejnery selžou, budou efektivně uvedeny zpět online.
Nízká :Použijte nejmenší základní kontejner, který poskytuje všechny nástroje potřebné k sestavení a spuštění vaší aplikace. Mnoho obrazů Dockeru je založeno na Alpine Linuxu, lehké a jednoduché distribuci Linuxu, která zabírá pouze 5 MB v obrazu Dockeru. Použití malé distribuce šetří síť a provozní režii a výrazně zvyšuje výkon kontejneru. Ukázková aplikace používá alpské obrázky tam, kde je to možné (NGINX, Redis a PostgreSQL), a základní obrázek python-slim pro aplikaci Gunicorn / Flask.
Bez státní příslušnosti :Protože jsou pomíjivé, kontejnery by obvykle neměly udržovat stav. Stav aplikace by měl být uložen v samostatném trvalém datovém objemu, jako je tomu v případě úložiště dat PostgreSQL mikroslužby. Úložiště párů klíč–hodnota Redis uchovává data v kontejneru, ale tato data nejsou kritická pro aplikaci; v případě, že kontejner nebude schopen reagovat, úložiště Redis se vrátí zpět do databáze.
Přenosné :Všechny závislosti aplikace, které jsou potřebné pro běh kontejneru, by měly být lokálně dostupné. Všechny závislosti a spouštěcí skripty ukázkové mikroslužby jsou uloženy v adresáři pro každou komponentu. Ty lze zkontrolovat ve správě verzí, což usnadňuje sdílení a nasazení aplikace.
Modulární :Každý kontejner by měl mít jednu odpovědnost a jeden proces. V této mikroslužbě je každý z hlavních procesů (NGINX, Python, Redis a PostgreSQL) nasazen v samostatném kontejneru.
Protokolování :Všechny kontejnery by se měly přihlásit do STDOUT . Tato jednotnost usnadňuje prohlížení protokolů všech procesů v jediném proudu.
Odolný :Vzorová aplikace restartuje své kontejnery, pokud jsou z nějakého důvodu ukončeny. To pomáhá zajistit vaší dockerizované aplikaci vysokou dostupnost a výkon, a to i během období údržby.

Další informace

Další informace o tomto tématu můžete získat v následujících zdrojích. Přestože jsou poskytovány v naději, že budou užitečné, vezměte prosím na vědomí, že nemůžeme ručit za přesnost nebo aktuálnost externě hostovaných materiálů.

Úložiště Github pro příklad mikroslužby
Použití kontejnerů k vytvoření architektury mikroslužeb

Přístup k webovému serveru Apache uvnitř kontejneru LXD Jak používat Docker Compose

Docker