Kuinka ottaa käyttöön korkean käytettävyyden sovellus Poudassa

Tämä on yksinkertainen korkean käytettävyyden selainsovelluksen käyttöönotto Poudassa. Meillä on vastaava opas korkeasta käytettävyydestä Rahdissa.

Kaavio

Pouta HA

Yllä olevassa kaaviossa näet lopputuloksen, jonka saavutat tämän oppaan lopussa. Otamme käyttöön kaksi URL-osoitetta: yhden itse sovellukselle (app.example.com) ja toisen valvontanäkymälle tai -näkymille (grafana.example.com). Sovellus toimii Frontend-virtuaalikoneilla, joista luomme kaksi replikaa. Frontend on yhdistetty Postgres-tietokantaan, joka toimii CSC:n Pukki database on demand -palvelussa. Valvonta toteutetaan Grafanalla ja Prometheuksella, jotka ovat kaksi hyvin yleisesti käytettyä valvontaohjelmistoratkaisua. Prometheus kerää frontendin tarjoamat metriikat, ja Grafana näyttää datan selkeinä kuvaajina.

Otamme jokaisen osan käyttöön vaihe vaiheelta ja kuvaamme niitä samalla tarkemmin.

Manuaalinen käyttöönotto

Luo virtuaalikoneet

Aloitamme luomalla 4 virtuaalikonetta: haproxy-1, haproxy-2, frontend-1, frontend-2 ja Monitoring. Voit seurata opasta luo uusi virtuaalikone. Luomme kaikki virtuaalikoneet heti alussa, jotta saamme niiden IP-osoitteet; tämä helpottaa verkkokonfiguraatiota. Muutama huomio:

Kiintiön ja resurssien säästämiseksi käytä pienintä saatavilla olevaa flavoria.
Tarvitsemme koko käyttöönottoon vain yhden floating IP -osoitteen, ja se liitetään aluksi koneeseen haproxy-1.
Varmista, että voit muodostaa SSH-yhteyden koneeseen haproxy-1. Tarvittaessa voit käyttää opasta Yhteyden muodostaminen virtuaalikoneeseen. Käytämme tätä konetta SSH-väli-isäntänä yhteyksien muodostamiseen muihin virtuaalikoneisiin.

Jotta voimme muodostaa SSH-yhteyden helposti jokaiseen koneeseen, luomme SSH-asetustiedoston:

mkdir -p ~/.ssh/config.d/
echo 'Include config.d/*' >>~/.ssh/config
cat >~/.ssh/config.d/pouta-ha-tutorial <<EOF
Host haproxy-1
    User ubuntu # Replace if not using an Ubuntu distribution
    Hostname <floating_IP> # Replace by the floating IP

Host haproxy-2
    User ubuntu
    ProxyJump haproxy-1
    Hostname <private_IP> # Replace by the private IP

Host frontend-1
    User ubuntu
    ProxyJump haproxy-1
    Hostname <private_IP> # Replace by the private IP

Host frontend-2
    User ubuntu
    ProxyJump haproxy-1
    Hostname <private_IP> # Replace by the private IP

Host Monitoring
    User ubuntu
    ProxyJump haproxy-1
    Hostname <private_IP> # Replace by the private IP
EOF

Tämän jälkeen voit muodostaa SSH-yhteyden mihin tahansa virtuaalikoneeseen suorittamalla vain ssh <virtuaalikoneen_nimi>, esimerkiksi koneeseen frontend-2:

ssh frontend-2

Kuormantasaaja

Kuormantasaukseen käytämme kahta HAProxy-virtuaalikonetta yhdessä Keepalivedin kanssa korkean käytettävyyden saavuttamiseksi kuormantasaajakerroksessa. haproxy-2:ssa toimiva Keepalived valvoo jatkuvasti konetta haproxy-1, ja jos se kaatuu, haproxy-2 ottaa Floating IP -osoitteen automaattisesti käyttöön OpenStack API:n avulla. Kun haproxy-1 palaa takaisin toimintaan, haproxy-1 käyttää jälleen OpenStack API:a saadakseen floating IP -osoitteen takaisin käyttöönsä.

Asenna ja määritä HAProxy

Tee jokainen vaihe sekä koneessa haproxy-1 että koneessa haproxy-2, sillä haluamme HAProxyn toimivan samalla tavalla molemmissa koneissa.

Asenna HAProxy, Keepalived ja OpenStack CLI:

sudo apt update && sudo apt install -y haproxy keepalived python3-openstackclient

Muokkaa tiedostoa /etc/haproxy/haproxy.cfg:

global
    log /dev/log local0
    maxconn 4096

defaults
    log     global
    mode    http
    option  httplog
    option  dontlognull
    timeout connect 5s
    timeout client  30s
    timeout server  30s

frontend http_front
    bind *:80
    # Route grafana.example.com -> grafana_back, everything else -> http_back
    acl is_grafana hdr(host) -i grafana.example.com
    use_backend grafana_back if is_grafana
    default_backend http_back

backend http_back
    balance roundrobin
    option httpchk GET /
    server frontend1 <FRONTEND_1_IP>:5000 check
    server frontend2 t <FRONTEND_2_IP>:5000 check

backend grafana_back
    balance roundrobin
    option httpchk GET /api/health
    server grafana1 <GRAFANA_IP>:3000 check

Korvaa <FRONTEND_1_IP> ja <FRONTEND_2_IP> koneiden frontend-1 ja frontend-2 sisäisillä IP-osoitteilla sekä <GRAFANA_IP> koneen Monitoring sisäisellä IP-osoitteella.

Ota HAProxy-palvelu käyttöön ja käynnistä se, jotta määritykset tulevat voimaan:
```
sudo systemctl enable --now haproxy
```

Määritä Keepalived

Luo failover-skripti /etc/keepalived/failover.sh molemmille HAProxy-virtuaalikoneille. Tämä skripti siirtää Floating IP -osoitteen sille noodille, josta tulee MASTER, käyttäen OpenStack CLI:tä:
```
#!/bin/bash
STATE=$3
FLOATING_IP_ID="<FLOATING_IP_ID>"

if [ "$STATE" = "MASTER" ]; then
    MY_PORT=$(openstack port list --server $(hostname) -f value -c ID | head -1)
    openstack floating ip set --port "$MY_PORT" "$FLOATING_IP_ID"
fi
```
Sovellustunnisteet

Skripti vaatii toimivat OpenStack-käyttöoikeustiedot kummallakin HAProxy-virtuaalikoneella. Luo sovellustunniste ja määritä se tiedostossa /etc/openstack/clouds.yaml molemmilla noodeilla.

Floating IP ID

Voit hakea floating IP:n tunnisteen suorittamalla: openstack floating ip list --port "$(openstack port list --server haproxy-1 -c ID -f value)"

Tee skriptistä suoritettava:

sudo chmod +x /etc/keepalived/failover.sh

Luo koneella haproxy-1 tiedosto /etc/keepalived/keepalived.conf:

vrrp_script chk_haproxy {
    script "systemctl is-active haproxy"
    interval 2
    weight -20
}

vrrp_instance VI_1 {
    state MASTER
    interface ens3
    virtual_router_id 51
    priority 100
    advert_int 1
    authentication {
        auth_type PASS
        auth_pass changeme
    }
    track_script {
        chk_haproxy
    }
    notify /etc/keepalived/failover.sh
}

Käytä koneella haproxy-2 samaa tiedostoa, mutta aseta state BACKUP ja priority 90; tämä tekee koneesta haproxy-1 ensisijaisen palvelimen.
Ota Keepalived käyttöön ja käynnistä se molemmilla noodeilla:
```
sudo systemctl enable --now keepalived
```

Avaa Security Group -portit

Lisää Poudan selainkäyttöliittymässä seuraavat security group -säännöt:

VM	Protocol	Port	Source
haproxy-1, haproxy-2	TCP	80	0.0.0.0/0
haproxy-1, haproxy-2	112 (VRRP)	-	Sisäinen verkko
frontend-1, frontend-2	TCP	5000	Sisäinen verkko

Lisätietoja Security Groupeista löytyy dokumentaatiostamme.

Tietokanta

Tietokanta tarjotaan Pukki DBaaS -palvelusta, joka on CSC:n hallinnoitu PostgreSQL-palvelu. Pukin käyttö poistaa tarpeen hallita tietokannan replikointia ja varmuuskopioita itse.

Seuraa Pukin aloitusopasta uuden PostgreSQL-instanssin luomiseksi. Luonnin yhteydessä:
- Kirjaa ylös julkinen IP-osoite
- Luo tietokanta ja käyttäjä, esimerkiksi nimillä ha (käyttäjä) ja ha (tietokanta), jotta ne vastaavat tässä oppaassa käytettyjä oletusarvoja.
- Aseta tietokantakäyttäjälle hyvä salasana
Salli Frontend-virtuaalikoneiden yhteys Pukkiin. Lisää Pukin selainkäyttöliittymässä frontend-1:n ja frontend-2:n käyttämä IP-osoite niiden egress IP -osoitteena sallittujen isäntien listaan. Saat tämän IP-osoitteen kirjautumalla jommallekummalle Frontend-palvelimelle ja suorittamalla:

curl ifconfig.me -4

Tai Poudan selainkäyttöliittymän kautta kohdassa Network → Routers ** napsauttamalla reitittimen nimeä. Löydät IP-osoitteen kohdasta External Fixed IPs kentän IP address** alta.

Frontend-virtuaalikoneet

Asennamme seuraavan testisovelluksen:

https://github.com/CSCfi/rahti-ha-tutorial/

Se on sama repositorio, jota käytetään aiemmin mainitussa Rahti-oppaassa. Se sisältää kaikki tarvittavat tiedostot, jotta sovellus voidaan ajaa myös Poudassa. Voit kloonata sen omalle koneellesi ja tarkastella koodia; kyseessä on yksinkertainen Python-sovellus. Sinun tulee tehdä nämä muutokset sekä koneessa frontend-1 että koneessa frontend-2; molemmat palvelimet ajavat samaa ohjelmistoa.

Varmista, että git on asennettu, ja kloonaa yllä mainittu repositorio:

sudo apt install -y git
git clone https://github.com/CSCfi/rahti-ha-tutorial /opt/rahti-ha-tutorial

Asenna Python 3 ja sovelluksen riippuvuudet:

sudo apt update && sudo apt install -y python3 python3-pip netcat-openbsd
cd /opt/rahti-ha-tutorial
python3 -m venv venv
. venv/bin/activate
pip3 install -r requirements.txt

Sovellus lukee tietokantayhteyden ympäristömuuttujista. Luo tiedosto niiden tallentamista varten:
```
sudo cat >/opt/rahti-ha-tutorial/.env <<EOF
DATABASE_URL=postgresql://ha:<DBPASSWORD>@<PUKKI_DB_HOST>:5432/ha
EOF
```
Korvaa DB_HOST ja DB_PASSWORD Pukki-tietokannasta saamillasi arvoilla.
Kopioi systemd-tiedosto rahti-ha-tutorial.service hakemistoon /etc/systemd/system/.
Ota palvelu käyttöön ja käynnistä se:
```
sudo systemctl daemon-reload
sudo systemctl enable --now rahti-ha-tutorial
```
Tämä käynnistää sovelluksen ja varmistaa myös, että se käynnistyy aina uudelleen virtuaalikoneen uudelleenkäynnistyksen yhteydessä.

Testaus

Ohjaa DNS-tietueesi (tai testauksessa paikallinen /etc/hosts) kuormantasaajan Floating IP -osoitteeseen:

<FLOATING_IP>  app.example.com
<FLOATING_IP>  grafana.example.com

Varmista, että sovellus on saavutettavissa kuormantasaajan kautta:

curl http://app.example.com/

Valvonta

Valvontaan käytämme Prometheusta metriikoiden keräämiseen Frontend-virtuaalikoneilta ja Grafanaa niiden visualisointiin. Molemmat ajetaan erillisellä Monitoring-virtuaalikoneella.

Asenna ohjelmistot

Muodosta SSH-yhteys Monitoring-virtuaalikoneeseen ja asenna Prometheus:
```
sudo apt update && sudo apt install -y prometheus
```

Grafanaa varten lisää virallinen repositorio ja asenna se:

sudo apt install -y apt-transport-https software-properties-common
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | \
    sudo tee /etc/apt/sources.list.d/grafana.list
sudo apt update && sudo apt install -y grafana

Määritä Prometheus

Muokkaa tiedostoa /etc/prometheus/prometheus.yml niin, että Flask-sovelluksen metriikat kerätään molemmilta Frontend-virtuaalikoneilta:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'ha-tutorial'
    static_configs:
      - targets:
          - '<FRONTEND_1_IP>:5000'
          - '<FRONTEND_2_IP>:5000'

Käynnistä Prometheus uudelleen:

sudo systemctl enable --now prometheus

Määritä Grafana

Käynnistä Grafana:

sudo systemctl enable --now grafana-server

Avaa Grafana käyttäen aiemmin määrittämääsi nimeä grafana.example.com:

Oletustunnukset ovat admin/admin.
Lisää Prometheus datalähteeksi: siirry kohtaan Connections → Data sources → Add data source, valitse Prometheus ja aseta URL-osoitteeksi http://localhost:9090. Napsauta Save & test. Tämä toimii, koska Prometheus toimii samalla virtuaalikoneella kuin Grafana.
Siirry kohtaan Explore, valitse Prometheus-datalähde ja syötä kysely:
```
rate(flask_app_request_count_total[5m])
```
Näet pyyntöjen määrän sekunnissa jokaiselle Frontend-instanssille samalla tavalla kuin Rahti-oppaassa.

Automatisoitu käyttöönotto Ansiblella

Kaikki yllä kuvatut manuaaliset vaiheet voidaan automatisoida ha-ansible -repositoriossa olevilla Ansible-playbookeilla. Kloonaa se ensin:

git clone https://github.com/lvarin/ha-ansible.git
cd ha-ansible

Esivaatimukset

Ansible ≥ 2.14 paikallisella koneellasi
OpenStack-käyttöoikeudet ladattuna:
```
source <project>-openrc.sh
```
SSH-avainpari rekisteröitynä Poudassa siten, että yksityinen avain on saatavilla paikallisesti
Pythonin openstackclient saatavilla paikallisesti (ad hoc -kyselyitä varten)
Toimiva tietokanta; suosittelemme Pukki DBaaS -palvelua, mutta mikä tahansa PostgreSQL-tietokanta käy. Tarvitset: db_host, db_port, db_user, db_password ja db_name.

Asenna tarvittava Ansible-kokoelma:

ansible-galaxy collection install -r requirements.yml

Määritä muuttujat

Muokkaa tiedostoa group_vars/all.yml ja korvaa jokainen REPLACE_WITH_*-paikkamerkki:

Variable	Description
`project_cidr`	Pouta-projektisi verkon CIDR (esim. `192.168.1.0/24`)
`keepalived_auth_pass`	Jaettu VRRP-salasana (valitse mikä tahansa vahva salasana)
`os_project_id` / `os_project_name`	OpenStack-projektisi
`os_application_credential_id` / `os_appliccation_credential_secret`	OpenStack-sovellustunnisteet failover-skriptiä varten
`db_host` / `db_password`	Pukki DBaaS -yhteystiedot (katso Tietokanta)

Note

Muuttuja floating_ip_id täytetään seuraavassa vaiheessa.

Luo tiedosto local.yml tiedostosta local.yml.example. Sinun tulee täyttää kaksi arvoa:

key_name, Poutaan rekisteröidyn avainparin nimi.
network, projektisi verkon nimi.

Provisionoi infrastruktuuri

ansible-playbook create_infra.yml

Kun ajo valmistuu, se tulostaa yhteenvedon, joka näyttää tältä:

inventory.ini
  haproxy1   ansible_host=<FLOATING_IP>
  haproxy2   ansible_host=<HAPROXY_2_PRIVATE_IP>
  frontend1  ansible_host=<FRONTEND_1_PRIVATE_IP>
  frontend2  ansible_host=<FRONTEND_2_PRIVATE_IP>
  monitoring ansible_host=<MONITORING_PRIVATE_IP>

group_vars/all.yml
  frontend_1_ip: <FRONTEND_1_PRIVATE_IP>
  frontend_2_ip: <FRONTEND_2_PRIVATE_IP>
  floating_ip_id: (run: openstack floating ip list)

Hae floating IP:n UUID ja lisää se tiedostoon group_vars/all.yml:

openstack floating ip list

Variable	Description
`floating_ip_id`	Yllä olevan komennon palauttaman floating IP:n UUID

Luo Pukki-tietokanta

Seuraa yllä olevaa osiota Tietokanta Pukki PostgreSQL -instanssin luomiseksi ja täytä sitten db_host ja db_password tiedostoon group_vars/all.yml.

Määritä kaikki virtuaalikoneet

ansible-playbook -i inventory.ini site.yml

Tämä yksi ajo määrittää kaikki viisi virtuaalikonetta kolmessa playssa:

HAProxy-play asentaa HAProxyn, Keepalivedin ja OpenStack CLI:n sekä ottaa käyttöön kuormantasaajan ja keepalive-määritykset.
Frontend-play kloonaa rahti-ha-tutorial Flask-sovelluksen ja ajaa sitä systemd-palveluna.
Monitoring-play asentaa Prometheuksen ja Grafanan.

Purkaminen

Jos haluat tuhota kaikki provisionoidut resurssit, aseta state: absent tiedostoon group_vars/all.yml ja suorita uudelleen:

ansible-playbook -i inventory.ini create_infra.yml

Tiedostoviite

.
├── create_infra.yml       # Provision VMs, security groups, and floating IP
├── site.yml               # Configure all VMs
├── inventory.ini          # Host list and SSH settings
├── requirements.yml       # Ansible collection dependencies
├── group_vars/
│   └── all.yml            # All variables (fill in REPLACE_WITH_* values)
└── templates/
    ├── haproxy.cfg.j2          # HAProxy load-balancer config
    ├── keepalived.conf.j2      # Keepalive config (master/backup priority)
    ├── failover.sh.j2          # Keepalived notify script (reassigns floating IP)
    ├── clouds.yaml.j2          # OpenStack credentials for the failover script
    ├── ha-tutorial.env.j2      # Flask app environment variables
    ├── ha-tutorial.service.j2  # systemd unit for the Flask app
    └── prometheus.yml.j2       # Prometheus scrape config

Yhteenveto

Tämä opas näyttää, kuinka rakennetaan korkean käytettävyyden selainsovellusratkaisu Poudassa käyttäen tavallisia avoimen lähdekoodin työkaluja. Toisin kuin Rahdissa, jossa alusta hoitaa kuormantasauksen, konttien orkestroinnin ja terveystarkistukset automaattisesti, Poudassa sinulla on täysi hallinta ja täysi vastuu jokaisesta kerroksesta:

HAProxy + Keepalived: tarjoavat kuormantasauksen ja automaattisen VIP-failoverin verkkokerroksessa.
Frontend-virtuaalikoneet: ajavat sovellusta ja käynnistyvät automaattisesti uudelleen systemd:n avulla.
Pukki DBaaS: tarjoaa hallinnoidun ja luotettavan PostgreSQL-taustajärjestelmän ilman itse hallitun replikoinnin monimutkaisuutta.
Prometheus + Grafana: keräävät ja visualisoivat sovelluksen metriikat kaikista Frontend-instansseista.

Tätä käyttöönottoa voidaan laajentaa useilla tavoilla:

Lisää HTTPS-päättäminen HAProxyyn Let's Encrypt -varmenteilla (esim. Certbotilla).
Lisää Grafana-hälytykset ilmoittamaan, kun virheiden määrä kasvaa äkillisesti tai taustapalvelu ei ole käytettävissä.
Korvaa Prometheuksen paikallinen tallennus pysyvällä Cinder-taltiolla, jotta metriikat säilyvät virtuaalikoneen uudelleenrakennuksen tai poistamisen jälkeen.