BEPRO Dev Team

Come operano i servizi serverless Python in BEPRO

Quali vantaggi otteniamo dallo sviluppo su una piattaforma serverless?

La maggior parte dei servizi backend di BEPRO è scritta in Python. Il servizio API principale è uno di questi. Il servizio opera attualmente su un'architettura serverless e lo stiamo distribuendo tramite Zappa, uno strumento di gestione serverless open source.

In questo articolo vorrei presentare brevemente come operano i servizi serverless in Python presso BEPRO.

Cos'è il Serverless?

Prima di parlare di serverless in BEPRO, penso sia utile dare una breve occhiata al concetto di serverless in sé. Innanzitutto, vediamo cosa dicono i "Big Three" dei fornitori cloud a proposito del serverless.

‍

Amazon AWS

Crea ed esegui applicazioni senza pensare ai server

AWS offre diversi servizi serverless. (Lambda, API Gateway, Aurora Serverless ecc.)

‍

Google Cloud

Sviluppa e distribuisci applicazioni e funzioni altamente scalabili su una piattaforma serverless completamente gestita.

Anche loro offrono alcuni servizi serverless (Cloud Run, Cloud Functions ecc.)

‍

MS Azure

Il nome serverless deriva dal fatto che le attività associate al provisioning e alla gestione dell'infrastruttura sono invisibili per lo sviluppatore.

‍

Infine, anche il blog di Martin Fowler (martinfowler.com), uno dei miei blog tecnici preferiti, parla di serverless.

Serverless è diventato un termine dominante in questo settore, dando il via alla nascita della serie di conferenze Serverless Conference e a vari fornitori Serverless che adottano il termine in qualsiasi ambito, dal marketing di prodotto alle descrizioni delle posizioni lavorative.

‍

Di conseguenza, sarebbe opportuno considerare il serverless come un "ambiente in cui gli sviluppatori possono sviluppare senza doversi preoccupare dell'infrastruttura", tramite servizi serverless forniti da cloud vendor come i "Big Three" menzionati sopra. Inoltre, l'articolo citato su martinfowler.com spiega in dettaglio il concetto, i pro e i contro del serverless; quindi, se sei interessato, ti consiglio vivamente di leggerlo prima di proseguire.

‍

Perché BEPRO ha adottato il Serverless?

Perché BEPRO ha adottato un ambiente serverless?

‍

Risorse di sviluppo limitate

Uno dei motivi principali è la situazione in cui si trovava BEPRO all'inizio dell'attività, dovendo sfruttare le risorse limitate nel modo più efficiente possibile. Avevamo bisogno di un ambiente in cui pochi sviluppatori potessero sviluppare e gestire i nostri prodotti considerando il meno possibile le infrastrutture, piuttosto che assumere nuovi sviluppatori DevOps, poiché all'epoca non sapevamo con quale rapidità sarebbe cresciuto il nostro servizio.

‍

Pattern di traffico API

Questo è un tipico pattern di chiamate API (misurato ogni secondo) nell'arco di tre ore durante un fine settimana. Il server gestisce da 10 a 20 volte il volume di richieste normali per un periodo brevissimo. Questo andamento è molto irregolare (a seconda dei calendari delle partite). In situazioni normali, sono sufficienti relativamente poche risorse infrastrutturali per gestire questo traffico, ma le risorse devono scalare orizzontalmente o verticalmente per un breve lasso di tempo al fine di garantire le stesse prestazioni nei momenti di picco. Questi pattern di traffico sono estremamente irregolari a seconda che si tratti di weekend/giorni feriali o di periodi di stagione/fuori stagione.

In questa situazione, dobbiamo o mantenere risorse infrastrutturali in grado di gestire il traffico di picco, oppure configurare un ambiente di auto-scaling. Nel primo caso, si sprecano costi; nel secondo caso, la scalabilità orizzontale o verticale potrebbe avvenire troppo tardi, perché il traffico è già diminuito mentre le risorse si stavano ridimensionando. Come accennato in precedenza, le nostre risorse (in particolare gli sviluppatori) erano piuttosto limitate per poter gestire l'infrastruttura tenendo conto di questi fattori.

In un ambiente serverless, gli sviluppatori non devono preoccuparsi di questi pattern di traffico, poiché i provider cloud che offrono servizi serverless gestiscono l'infrastruttura in autonomia. Adottando un approccio serverless, abbiamo pensato che i nostri sviluppatori potessero concentrarsi sullo sviluppo della logica di business e delle funzionalità. Grazie al serverless, siamo stati anche in grado di lanciare rapidamente le nostre nuove funzionalità.

‍

Costi

Oltre alla prospettiva della gestione del sistema, abbiamo confrontato approssimativamente il costo stimato di un ambiente serverless AWS e di un ambiente server tradizionale. (Costi specifici come RDS, Load Balancer e S3 non sono considerati, trattandosi unicamente di una stima approssimativa).

Ipotesi: 2.000.000 di richieste / mese

Possiamo notare che l'ambiente serverless di AWS è circa il 70% più economico.

Bepro ha adottato un ambiente serverless, nonostante alcuni svantaggi come il numero limitato di esecuzioni simultanee, il tempo di esecuzione limitato, il ritardo di cold start, ecc. (Vedi i pro e i contro generali del serverless.)

‍

Architettura Serverless in Bepro

Abbiamo deciso di utilizzare i servizi serverless di AWS. L'architettura di BEPRO è riassunta brevemente di seguito. (Dettagli come CDN, S3, ecc. sono omessi per mostrare esclusivamente l'ambiente serverless.)

‍

‍

Abbiamo cercato di ottimizzare la latenza di risposta delle nostre API configurando Europa e Asia come regioni multiple per fornire servizi a livello globale. Abbiamo inoltre distribuito un ambiente Lambda utilizzando container Docker. Tutta questa gestione serverless viene effettuata tramite Zappa, uno strumento open source.

‍

Distribuire servizi web Python con Zappa

Ora distribuiremo servizi web Python con Zappa.

Se distribuisci servizi web su AWS serverless senza Zappa, ti ritroverai con un bel grattacapo perché ci sono tantissime cose da considerare, come i ruoli IAM, il packaging del codice, le impostazioni di API Gateway/Lambda, ecc. — Zappa gestisce tutto questo automaticamente.

Vediamo come distribuire un servizio web Python Django serverless basato su Docker con Zappa.

‍

Impostazioni del progetto Django

Innanzitutto, crea un ambiente virtuale Python e installa Django.

(venv)> pip install django

Crea un progetto Django.

(venv)> django-admin startproject zappa-example
(venv)> cd zappa-example

ALLOWED_HOSTS nelle impostazioni di Django è stato modificato. Inoltre, abbiamo commentato le impostazioni relative al database per eseguire questo esempio senza problemi.

‍

... (salta) ...
ALLOWED_HOSTS = ["*"]
... (salta) ...
# DATABASES = {
#     'default': {
#         'ENGINE': 'django.db.backends.sqlite3',
#         'NAME': 'mydatabase',
#     }
# }... (salta) ...

‍

Esegui un server Django nel tuo ambiente locale.

‍

(venv) python manage.py runserver

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 18 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.
June 14, 2022 - 15:09:23
Django version 4.0.5, using settings 'zappa_example.settings'
Starting development server at <http://127.0.0.1:8000/>
Quit the server with CONTROL-C.

‍

Possiamo connetterci al server Django locale tramite il browser. (In questo esempio non implementeremo alcuna funzione, ma testeremo semplicemente accedendo alla pagina di login dell'amministratore di Django.)

‍

‍

Impostazioni di Zappa

Dobbiamo configurare le nostre credenziali AWS prima di completare le impostazioni di Zappa.

Per prima cosa, installa awscli.

> pip install awscli

Configura le credenziali AWS utilizzando il comando aws configure.

> aws configure

Installa la libreria Zappa nell'ambiente virtuale Python creato in precedenza.

(venv)> pip install zappa

Prima di inizializzare Zappa, crea un file requirements.txt per specificare le dipendenze. (Verrà utilizzato successivamente per il deployment con Docker.)

(venv)> pip freeze >> requirments.txt

Inizializza Zappa.

(venv)> zappa init

Entreremo nella modalità interattiva per le impostazioni di Zappa. Ho proceduto con i valori predefiniti. Una cosa da notare durante la procedura è che Zappa ha riconosciuto che la nostra directory è un progetto Django e l'ha configurata automaticamente.

‍

‍

Inserisci il comando “ls”.

‍(venv)> ls
db.sqlite3          manage.py           zappa_example      
zappa_settings.json

‍

È stato creato il file zappa_settings.json. Vediamone il contenuto.

{
   "dev": {
       "aws_region": "ap-northeast-2",
       "django_settings": "zappa_example.settings",
       "profile_name": "default",
       "project_name": "zappa-example",
       "runtime": "python3.8",
       "s3_bucket": "zappa-yyamukhwg"
   }
}

‍

È stato creato uno stage dev. (Predefinito.) È possibile creare più stage (staging, produzione, ecc.) e ciascuno può essere distribuito.

aws_region : regione AWS in cui effettuare il deployment.
django_settings : se si tratta di un progetto Django, specifica il percorso del file delle impostazioni di Django.
profile_name : profilo di configurazione di AWS CLI.
project_name : nome del progetto per la funzione Lambda.
runtime : ambiente di runtime per Lambda (non richiesto per il deployment con immagine Docker).
s3_bucket : il bucket S3 su cui caricare il pacchetto di deployment (file zip).

‍

Il deployment con Zappa è semplicissimo.

(venv)> zappa deploy dev

... (salta) ...
Deployment complete!: <https://7qi7rn36uf.execute-api.ap-northeast-2.amazonaws.com/dev>

‍

Comprime il codice in un file zip, lo carica nel bucket S3, crea la funzione Lambda, imposta API Gateway, ecc. — Zappa gestisce molteplici processi di deployment con un solo comando.

Possiamo verificare che la pagina di amministrazione sia accessibile utilizzando l'ultimo URL di output. (Lo stile non è applicato perché i file statici non sono stati distribuiti.)

‍

‍

Possiamo rimuovere completamente la nostra applicazione distribuita.

(venv)> zappa undeploy
‍

Successivamente, effettueremo il deployment con un'immagine Docker.

‍

Creazione di un'immagine Docker

Crea un Dockerfile.

‍

FROM amazon/aws-lambda-python:3.8  # 1

ARG FUNCTION_DIR="/var/task/"

WORKDIR ${FUNCTION_DIR}

COPY ./ ${FUNCTION_DIR}
‍
# Install packages
RUN pip install -r requirements.txt

# Grab the zappa handler.py and put it in the working directory
RUN ZAPPA_HANDLER_PATH=$( \\
   python -c "from zappa import handler; print (handler.__file__)"
\\
   ) \\
   && echo $ZAPPA_HANDLER_PATH \\
    && cp $ZAPPA_HANDLER_PATH ${FUNCTION_DIR}

CMD [ "handler.lambda_handler" ]  # 2

‍

#1 : Abbiamo utilizzato un'immagine basata su Lambda fornita da AWS (Vedi)

#2 : Esegui un gestore Lambda fornito da Zappa. (Gestirà le richieste di API Gateway e le indirizzerà al server Django.)

Crea un file di impostazioni per il deployment di Docker prima di compilare l'immagine.

‍

(venv)> zappa save-python-settings-file dev

‍

Formato zappa save-python-settings-file <stage_name>

‍

In generale, con il deployment di Zappa basato su file zip, un file di impostazioni Python viene impacchettato nel file zip. Lo stesso file (zappa_settings.py) viene creato e verrà incluso nell'immagine Docker.

‍

Ora compila l'immagine.

> docker build -t zappa-example:latest .

‍

Push di un'immagine Docker

Crea un repository AWS ECR.

> aws ecr create-repository --repository-name zappa-example --image-scanning-configuration scanOnPush=true

‍

Riassegna il tag.

> docker tag zappa-example:latest XXXXXXXXXXXX.dkr.ecr.ap-northeast-2.amazonaws.com/zappa-example:latest

‍

Accedi all'AWS ECR che hai creato sopra.

> aws ecr get-login-password | docker login --username AWS --password-stdin XXXXXXXXXXXX.dkr.ecr.ap-northeast-2.amazonaws.com/zappa-example

‍

Esegui il push dell'immagine su ECR.

> docker push XXXXXXXXXXXX.dkr.ecr.ap-northeast-2.amazonaws.com/zappa-example:latest

‍

Distribuzione con un'immagine Docker

Infine, distribuisci un servizio web serverless con immagine Docker su AWS serverless.

(venv)> zappa deploy dev -d XXXXXXXXXXXX.dkr.ecr.ap-northeast-2.amazonaws.com/zappa-example:latest

... (salta) ...
Deployment complete!: <https://g9vu4sutk2.execute-api.ap-northeast-2.amazonaws.com/dev>

‍

Verifica se il deployment è riuscito accedendo all'URL generato.

‍

‍

Se hai già distribuito l'applicazione, ti verrà richiesto di aggiornare il codice dell'applicazione più recente su AWS utilizzando i seguenti comandi.

(venv)> zappa save-python-settings-file dev
> docker build -t XXXXXXXXXXXX.dkr.ecr.ap-northeast-
2.amazonaws.com/zappa-example:latest .
> docker push XXXXXXXXXXXX.dkr.ecr.ap-northeast-
2.amazonaws.com/zappa-example:latest
(venv)> zappa update dev -d XXXXXXXXXXXX.dkr.ecr.ap-northeast-
2.amazonaws.com/zappa-example:latest

‍

Usa zappa update invece di zappa deploy

‍

Dominio personalizzato con SSL

Utilizzeremo AWS Route 53 per il dominio e AWS Certificate Manager per il certificato SSL.

Presumo che il dominio e il certificato siano stati emessi completamente.

Per prima cosa, modifica zappa_settings.json aggiungendo i valori per domain e certificate_arn.

{
   "dev": {
       "aws_region": "ap-northeast-2",
       "django_settings": "zappa_example.settings",
       "profile_name": "default",
       "project_name": "zappa-example",
       "s3_bucket": "zappa-yyamukhwg",
       **"domain": "zappa.cwoojin.com",**
       **"certificate_arn": "arn:aws:acm:us-east-
1:XXXXXXXXXXXX:certificate/eba3fd6b-a1f4-4e6a-b5d6-fe7aa8c88649"**
   }
}

‍

Infine, basta fare il deploy!

(venv)> zappa certify
(venv)> zappa update dev -d XXXXXXXXXXXX.dkr.ecr.ap-northeast-
2.amazonaws.com/zappa-example:latest

..(salta)...
Your updated Zappa deployment is live!: <https://zappa.cwoojin.com> (<https://g9vu4sutk2.execute-api.ap-northeast-2.amazonaws.com/dev>)

‍

Verifica se la connessione al dominio registrato è avvenuta con successo. (https://zappa.cwoojin.com.)

‍

‍

La configurazione di base del deployment è ora completa.

(Non dimenticare di rimuovere questo esempio tramite undeploy dal tuo account AWS.)

‍

Impostazioni Zappa in BEPRO

Condivido alcune parti dello zappa_settings.json che utilizziamo in BEPRO.

BEPRO gestisce un ambiente di deployment suddiviso in più stage (dev, test, prod, ecc.)

Consulta la documentazione ufficiale di Zappa per l'utilizzo avanzato di Zappa.

{
 "dev": {
   "aws_region": "eu-central-1",
   "django_settings": "xxx",
   "project_name": "xxx",
   "s3_bucket": "xxx",
   "environment_variables": {
     ...
   },
   "certificate_arn": "xxx",
   "domain": "xxx",
   "route53_enabled": false,    "cors": {
     "allowed_headers": [xxx]
   },
   "exception_handler": "xxx",
   "keep_warm_expression": "xxx",
   "memory_size": xxx,
   "payload_compression": xxx,
   "payload_minimum_compression_size": xxx,
   "lambda_description": "xxx",
   "vpc_config": {
     "SubnetIds": [xxx],
     "SecurityGroupIds": [xxx]
   }
},  
"prod_base": {
   ... (salta) ...
 },
 "prod": {
   "extends": "prod_base",
   "events": [{
     "function": "task_1",
     "expression": "cron(0/2 * * * ? *)"
   }, {
     "function": "task_2",
     "expression": "cron(* * * * ? *)"
 },]
... (salta) ...
 },
 "prod_asia": {
   ... (salta) ...
 },
 "test": {
   "extends": "dev",
   ... (salta) ...
 },
 ... (salta) ...
}

‍

Conclusioni

In questo articolo ho spiegato brevemente cosa significa serverless, perché BEPRO ha adottato il serverless e come distribuire servizi web serverless in Python con Zappa.

Zappa supporta varie funzionalità oltre a quella di deployment serverless illustrata in questo articolo. Ad esempio, offre opzioni che semplificano l'invocazione di una funzione Lambda direttamente dalla logica dell'applicazione per eseguire attività asincrone, oppure la registrazione di scheduler per eseguire attività regolari come funzioni Lambda.

Abbiamo infine creato un ambiente di deployment serverless utilizzando GitHub Actions e Zappa. Questo ambiente ha permesso ai nostri sviluppatori di concentrarsi maggiormente sulla logica di business. Ancora oggi ci sono sfide da risolvere per migliorare l'ambiente serverless e siamo costantemente impegnati a trovare soluzioni a questi problemi.

Infine, se stai pensando di realizzare un servizio web serverless in Python, spero che questo articolo ti sia stato utile.

Grazie!

‍

‍