I den här artikeln kommer jag att dela med mig av min erfarenhet av att konfigurera CI/CD med hjälp av kontrollpanelen Plesk och Github Actions. Idag ska vi lära oss att distribuera ett enkelt projekt med den okomplicerade titeln "Helloworld". Det är skrivet i Python-ramverket Flask, med arbetare på Celery och frontend på Angular 8.

Länkar till repositoryn: backend, frontend.

I den första delen av artikeln kommer vi att titta på vårt projekt och dess delar. I den andra kommer vi att gå igenom hur man konfigurerar Plesk och installerar nödvändiga tillägg och komponenter (DB, RabbitMQ, Redis, Docker, etc.).

I den tredje delen kommer vi äntligen att ta reda på hur man ställer in en pipeline för att distribuera vårt projekt på servern i dev- och prod-miljö. Och sedan kommer vi att starta webbplatsen på servern.

Och ja, jag glömde att presentera mig. Jag heter Oleg Borzov, jag är fullstack-utvecklare i CRM-teamet för hypotekslåneledare på Domklik.

Projektöversikt

Först ska vi titta på två repositoryn för projektet — backend och frontend — och gå igenom koden.

Backend-del: Flask+Celery

För backend-delen har jag valt en ganska populär kombination bland Python-utvecklare: ramverket Flask (för API) och Celery (för uppgiftskö). SQLAlchemy används som ORM. Alembic används för migreringar. För validering av JSON i endpoints — Marshmallow.

I förrådet det finns en fil Readme.md med en detaljerad beskrivning av strukturen och instruktioner för att köra projektet.

API-webbdel ganska okomplicerat, består av 6 endpoints:

• /ping — för att kontrollera tillgänglighet;
• endpoints för registrering, autentisering, avregistrering och att hämta den autentiserade användaren;
• endpoint för att skicka e-post, som lägger en uppgift i Celery-kön.

Celery-del ännu enklare, det finns bara en uppgift send_mail_task.

I mappen /conf det finns två undermappar:

• docker med två Docker-filer (base.dockerfile för att skapa en sällan ändrad basbild och Dockerfile för huvudbyggnationerna);
• .env_files — med filer för miljövariabler för olika miljöer.

I roten av projektet finns fyra docker-compose-filer:

• docker-compose.local.db.yml för att starta en lokal databas för utveckling;
• docker-compose.local.workers.yml för lokal uppstart av arbetare, databas, Redis och RabbitMQ;
• docker-compose.test.yml för att köra tester vid distribution;
• docker-compose.yml för distribution.

Och den sista intressanta mappen för oss — .ci-cd. Den innehåller shell-skript för distribution:

• deploy.sh — körning av migreringar och distribution. Startas på servern efter byggnation och körning av tester i Github Actions;
• rollback.sh — återställning av containrar till föregående version av bygget;
• curl_tg.sh — skickar meddelanden om distribution till Telegram.

Frontend på Angular

Repository with the front end is much simpler than the back end. The front consists of three pages:

• The main page with a form to send an email and a logout button.
• Login page.
• Registration page.

The main page looks minimalistic:

At the root, there are two files Dockerfile och docker-compose.yml, as well as the familiar folder .ci-cd with slightly fewer scripts than in the back-end repository (scripts for running tests have been removed).

Setting up the project in Plesk

Let's start with configuring Plesk and creating a subscription for our site.

Installing extensions

In Plesk, we will need four extensions:

• Docker for managing and visually displaying the status of containers in the Plesk admin panel;
• Git for setting the deployment step on the server;
• Let's Encrypt for generating (and auto-renewing) free TLS certificates;
• Firewall for configuring incoming traffic filtering.

They can be installed through the Plesk admin panel in the Extensions section:

We won't discuss the detailed configuration of the extensions, the default settings will suffice for our demo purposes.

Creating a subscription and a site

Next, we need to create a subscription for our site helloworld.ru and add the subdomain dev.helloworld.ru.

1. Create a subscription for the domain helloworld.ru and specify the username-password for the system user:

   
   At the bottom of the page, we check the box Secure the domain with Let’s Encrypt, if we want to set up HTTPS for the website:

   

2. Next, in this subscription, we create the subdomain dev.helloworld.ru (for which a free TLS certificate can also be issued):

   

Installing server components

We have a server with OS Debian Stretch 9.12 and the control panel installed Plesk Obsidian 18.0.27.

We need to install and configure for our project:

• PostgreSQL (in our case, there will be one server with two databases for dev and prod environments).
• RabbitMQ (the same, one instance with different vhosts for environments).
• Two instances of Redis (for dev and prod environments).
• Docker Registry (for local storage of built Docker images).
• UI interface for Docker registry.

PostgreSQL

The package already includes a PostgreSQL DBMS in Plesk, but it's not the latest version (at the time of writing, Plesk Obsidian supported Postgres versions 8.4–10.8). We want the latest version for our application (12.3 at the time of writing), so we will install it manually.

There are plenty of detailed instructions for installing Postgres on Debian online (exempel), so I won't describe them in detail, just provide the commands:

wget -q https://www.postgresql.org/media/keys/ACCC4CF8.asc -O - | sudo apt-key add -
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt/ stretch-pgdg main" >> /etc/apt/sources.list.d/pgdg.list'

sudo apt-get update
sudo apt-get install postgresql postgresql-contrib

Eftersom PostgreSQL har ganska medelmåttiga standardinställningar är det viktigt att justera konfigurationen. Det kan vi få hjälp med av kalkylator: vi behöver ange parametrarna för vår server och ersätta inställningarna i filen /etc/postgresql/12/main/postgresql.confmed de föreslagna. Här ska det tilläggas att sådana kalkylatorer inte är en universallösning, och databasen bör justeras mer exakt baserat på din hårdvara, applikationen och komplexiteten i frågorna. Men för att börja är detta tillräckligt.

Förutom de av kalkylatorn föreslagna inställningarna ändrar vi även postgresql.confden standardport som är angiven 5432 till en annan (i vårt exempel - 53983).

Efter att vi har ändrat konfigurationsfilen, startar vi om postgresql-servern med kommandot:

service postgresql restart

Vi har installerat och konfigurerat PostgreSQL. Nu ska vi skapa databaser, användare för dev- och prod-miljöer, och ge användarna rättigheter att hantera databasen:

$ su - postgres
postgres:~$ create database hw_dev_db_name;
CREATE DATABASE
postgres:~$ create user hw_dev_db_user with password 'hw_dev_db_password';
CREATE ROLE
postgres:~$ grant ALL privileges ON database hw_dev_db_name to hw_dev_db_user;
GRANT
postgres:~$ create database hw_prod_db_name;
CREATE DATABASE
postgres:~$ create user hw_prod_db_user with password 'hw_prod_db_password';
CREATE ROLE
postgres:~$ grant ALL privileges ON database hw_prod_db_name to hw_prod_db_user;
GRANT

RabbitMQ

Låt oss gå vidare till installationen av RabbitMQ — meddelandebrokern för Celery. Det installeras ganska enkelt på Debian:

wget https://packages.erlang-solutions.com/erlang-solutions_1.0_all.deb
sudo dpkg -i erlang-solutions_1.0_all.deb

sudo apt-get update
sudo apt-get install erlang erlang-nox

sudo add-apt-repository 'deb http://www.rabbitmq.com/debian/ testing main'
wget -O- https://www.rabbitmq.com/rabbitmq-release-signing-key.asc | sudo apt-key add -

sudo apt-get update
sudo apt-get install rabbitmq-server

Efter installationen behöver vi skapa vhosts, användare och ge dem nödvändiga rättigheter:

sudo rabbitmqctl add_user hw_dev_amqp_user hw_dev_amqp_password 
sudo rabbitmqctl set_user_tags hw_dev_amqp_user administrator
sudo rabbitmqctl add_vhost hw_dev_vhost
sudo rabbitmqctl set_permissions -p hw_dev_vhost hw_dev_amqp_user ".*" ".*" ".*"

sudo rabbitmqctl add_user hw_prod_amqp_user hw_prod_amqp_password 
sudo rabbitmqctl set_user_tags hw_prod_amqp_user administrator
sudo rabbitmqctl add_vhost hw_prod_vhost
sudo rabbitmqctl set_permissions -p hw_prod_vhost hw_prod_amqp_user ".*" ".*" ".*"

Redis

Nu ska vi installera och konfigurera den sista komponenten för vår applikation — Redis. Den kommer att användas som backend för att lagra resultaten av uppgifter i Celery.

Vi kommer att starta två Docker-containrar med Redis för dev- och prod-miljöer med hjälp av tillägget Docker för Plesk.

1. Logga in på Plesk, gå till avsnittet Tillägg, sök efter tillägget Docker och installera det (vi behöver gratisversionen):

   

2. Gå till det installerade tillägget, sök efter bilden redis bitnami och installera den senaste versionen:

   

3. Gå in i den nedladdade containern och justera konfigurationen: ange port, maximalt tilldelat RAM-minne, lösenord i miljövariabler och montera volymen:

   

4. Utför steg 2-3 för prod-containern, ändra bara inställningarna: port, lösenord, RAM-storlek och sökväg till volymmappen på servern:

   

Docker Registry

Förutom grundläggande tjänster skulle det vara bra att installera ett eget Docker-bildarkiv på servern. Tack vare att utrymme på servrar nu är ganska billigt (definitivt billigare än en prenumeration på DockerHub), och installationen av ett privat arkiv är mycket enkel.

Vi vill att följande ska vara installerade:

• ett lösenordsskyddat Docker-arkiv, tillgängligt via en subdomän https://docker.helloworld.ru;
• Ett användargränssnitt för att visa bilder i arkivet, tillgängligt på adressen https://docker-ui.helloworld.ru.

För detta:

1. Vi skapar två subdomäner i Plesk i vår prenumeration: docker.helloworld.ru och docker-ui.helloworld.ru, och konfigurerar Let's Encrypt-certifikat för dem.
2. I mappen för subdomänen docker.helloworld.ru lägger vi till filen docker-compose.yml med följande innehåll:

   version: "3"
   
   services:
     docker-registry:
       image: "registry:2"
       restart: always
       ports:
         - "53985:5000"
       environment:
         REGISTRY_AUTH: htpasswd
         REGISTRY_AUTH_HTPASSWD_REALM: basic-realm
         REGISTRY_AUTH_HTPASSWD_PATH: \/auth\/.htpasswd
         REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY: \/data
       volumes:
         - .\/\.docker-registry.htpasswd:\/auth\/.htpasswd
         - .\/data:\/data
   
     docker-registry-ui:
       image: konradkleine\/docker-registry-frontend:v2
       restart: always
       ports:
         - "53986:80"
       environment:
         VIRTUAL_HOST: '*, https:\/\/*'
         ENV_DOCKER_REGISTRY_HOST: 'docker-registry'
         ENV_DOCKER_REGISTRY_PORT: 5000
       links:
         - 'docker-registry'
   

3. Genom SSH ska vi generera filen .htpasswd för grundläggande autentisering i Docker-arkivet:

   htpasswd -bBc .htpasswd hw_docker_admin hw_docker_password

4. Bygg och starta containrarna:

   docker-compose up -d

5. Och vi behöver dirigera Nginx till våra containrar. Det kan göras via Plesk.

Följande åtgärder måste vidtas för subdomänerna docker.helloworld.ru och docker-ui.helloworld.ru:

I avsnittet Dev Tools på vår webbplats går vi till Docker Proxy Rules:

Och lägg till en regel för att proxy-trafiken till vår container:

1. Kontrollera att vi kan logga in på vår container från den lokala maskinen:

   $ docker login docker.helloworld.ru -u hw_docker_admin -p hw_docker_password
   WARNING! Using --password via the CLI is insecure. Use --password-stdin.
   Login Succeeded

2. Vi kontrollerar också att subdomänen docker-ui.helloworld.ru fungerar:

   
   När du trycker på Browse repositories kommer webbläsaren att visa en inloggningsruta där du behöver ange användarnamn och lösenord för lagret. Efter det tas du till en sida med en lista över lagren (den kommer vara tom för dig just nu):

   

Öppna portar i Plesk Firewall

Efter installation och konfiguration av komponenterna behöver vi öppna portar så att komponenterna blir tillgängliga från Docker-containrar och från det externa nätverket.

Låt oss se hur detta görs med hjälp av det tidigare installerade Firewall-tillägget för Plesk.

1. Vi går till Verktyg & Inställningar > Inställningar > Brandvägg:
   
2. Vi går till Ändra Plesk Firewall-regler > Lägg till anpassad regel och öppna följande TCP-portar för Docker-undernätet (172.0.0.0/8):
   RabbitMQ: 1883, 4369, 5671-5672, 25672, 61613-61614
   Redis: 32785, 32786

   

3. Låt oss också lägga till en regel som öppnar portar för PostgreSQL och RabbitMQ:s administrationspanel för omvärlden:

   

4. Tillämpa reglerna med hjälp av knappen Tillämpa ändringar:

   

Konfiguration av CI/CD i Github Actions

Låt oss gå till den mest intressanta delen — konfigurationen av pipeline för kontinuerlig integration och leverans av vårt projekt till servern.

Denna pipeline kommer att bestå av två delar:

• bygga bilden och köra tester (för backend) — på Github-sidan;
• köra migrationer (för backend) och distribuera containrar — på servern.

Distribution i Plesk

Vi börjar med det andra punkten (eftersom det påverkar det första).

Vi kommer att konfigurera distributionsprocessen med hjälp av Git-tillägget för Plesk.

Vi tar ett exempel med produktionsmiljön för Backend-lagret.

1. Gå till prenumerationen för vår webbplats Helloworld och navigera till avsnittet Git:

   

2. Klistra in länken till vårt Github-lager i fältet "Remote Git repository" och ändra standardmappen httpdocs till en annan (till exempel, /httpdocs/hw_back):

   

3. Kopiera SSH-public key från föregående steg och lägg till sätt in den i inställningarna för Github.
4. Klicka på OK på skärmen under punkt 2, efter vilket du tas till sidan för lagret i Plesk. Nu måste vi ställa in uppdateringen av lagret vid commit till master-grenen. För detta går vi till Repository Settings och sparar värdet Webhook URL (det kommer att behövas senare för att konfigurera Github Actions):

   

5. I fältet Actions på skärmen från föregående punkt, skriv in skriptet för att starta distributionen:

   cd {REPOSITORY_ABSOLUTE_PATH}
   .ci-cd/deploy.sh {ENV} {DOCKER_REGISTRY_HOST} {DOCKER_USER} {DOCKER_PASSWORD} {TG_BOT_TOKEN} {TG_CHAT_ID} 

   där:

   {REPOSITORY_ABSOLUTE_PATH} — vägen till prod-mappen för backend-lagret på servern;
   {ENV} — miljö (dev/prod), i vårt fall prod;
   {DOCKER_REGISTRY_HOST} — värden för vårt docker-lager
   {TG_BOT_TOKEN} — token för Telegram-botten;
   {TG_CHAT_ID} — ID för chatten/kanalen för att skicka notifieringar.

   Exempel på skript:

   cd /var/www/vhosts/helloworld.ru/httpdocs/hw_back/
   .ci-cd/deploy.sh dev docker.helloworld.ru docker_user docker_password 12345678:AAbcdEfghCH1vGbCasdfSAs0K5PALDsaw -1001234567890

6. Lägg till användaren från vår prenumeration i Docker-gruppen (så att han kan hantera containrar):

   sudo usermod -aG docker helloworld_admin

Utvecklingsmiljön för backend-repositoriet och frontend ställs in på samma sätt.

Deploy-pipeline i Github Actions

Låt oss gå vidare med att konfigurera första delen av vår CI/CD-pipeline i Github Actions.

Backend

Pipelinen beskrivs i filen deploy.yml.

Men innan vi går igenom den behöver vi fylla i de nödvändiga hemliga variablerna i Github. För detta går vi till Inställningar -> Hemliga:

• DOCKER_REGISTRY — värd för vårt Docker-repositorium (docker.helloworld.ru);
• DOCKER_LOGIN — inloggning till Docker-repositoriet;
• DOCKER_PASSWORD — lösenordet till det;
• DEPLOY_HOST — värd där Plesk-administrationspanelen är tillgänglig (exempel: helloworld.ru:8443 eller 123.4.56.78:8443);
• DEPLOY_BACK_PROD_TOKEN — token för att deploya till prod-repositoriet på servern (vi fick det i Deploy till Plesk punkt 4);
• DEPLOY_BACK_DEV_TOKEN — token för att deploya till dev-repositoriet på servern.

Deploy-processen är enkel och består av tre huvudsteg:

• bygge och publicering av bilden i vårt repositorium;
• körning av tester i containern baserat på den nybyggda bilden;
• deployering till rätt miljö beroende på grenen (dev/master).

Frontend

Filen deploy.yml för frontend-repositoriet skiljer sig inte mycket från backend-versionen. Den saknar steget med att köra tester och namnen på tokens för deployering ändras. Hemligheterna för frontend-repositoriet måste förresten fyllas i separat.

Webbplatsinställning

Proxytrafik genom Nginx

Nåväl, vi har kommit till slutet. Det återstår bara att ställa in proxytrafik för inkommande och utgående trafik till vår container genom Nginx. Denna process har vi redan gått igenom i punkt 5 i Docker Registry-inställningarna. Samma sak måste upprepas för backend- och frontend-delarna i dev- och prod-miljöerna.

Jag kommer att visa skärmdumpar av inställningarna.

Backend

Frontend

Viktig anmärkning. I frontend-containern kommer alla URL:er att proxas, förutom de som börjar med /api/ — de kommer att proxas till backend-containern (därför måste i backend-containern alla handhavanden börja med /api/).

Sammanfattning

Nu bör vår webbplats vara tillgänglig på adresserna helloworld.ru och dev.helloworld.ru (prod- och dev-miljöer respektive).

Sammanfattningsvis har vi lärt oss hur man förbereder en enkel applikation på Flask och Angular och hur man ställer in en pipeline i Github Actions för att lansera den på en server som styrs av Plesk.

Jag vill också dela länkar till reporna med koden: backend, frontend.

Källa: habr.com