GNU/Linux >> Linux Esercitazione > >> Panels >> Docker

Distribuisci un'applicazione Flask con Dokku

Dokku è una Platform-as-a-Service (PaaS) self-hosted che semplifica la distribuzione delle applicazioni utilizzando Git. Sebbene l'implementazione di Dokku sia simile a Heroku, manca di alcune funzionalità chiave come il ridimensionamento automatico. Dokku è uno strumento estremamente potente che esegue automaticamente la tua applicazione all'interno di Docker e richiede una configurazione minima dei server web.

Questa guida mostra come:

Crea un'applicazione Flask che restituisca "Hello World!" nella pagina dell'indice
Installa Dokku su un Linode
Distribuisci un'applicazione Flask con un server WSGI all'interno di un container Docker
Aggiungi un certificato SSL tramite Dokku con il plug-in Let's Encrypt

Prima di iniziare

Sul tuo computer locale

Nota Dokku v0.12.5 è compatibile con Ubuntu 16.04 x64, Ubuntu 14.04 x64 e Debian 8.2 x64. CentOS 7 x64 è supportato solo in via sperimentale e, pertanto, alcuni passaggi come la configurazione delle chiavi SSH e degli host virtuali devono essere eseguiti manualmente utilizzando l'interfaccia della riga di comando dokku. Consulta la documentazione ufficiale per ulteriori informazioni.

Si presume che una chiave pubblica sia disponibile. In genere si trova in ~/home/username/.ssh/id_rsa.pub .

Installa Git se necessario:

sudo apt install git

Sul tuo Linode

Lo script di installazione di Dokku crea un dokku utente sul sistema, installa Docker ed estrae l'immagine pertinente.

Scarica lo script di installazione da Dokku, quindi esegui lo script:

wget https://raw.githubusercontent.com/dokku/dokku/v0.12.5/bootstrap.sh
sudo DOKKU_TAG=v0.12.5 bash bootstrap.sh

Preparing to install v0.11.6 from https://github.com/dokku/dokku.git...
For dokku to build containers, it is strongly suggested that you have 1024 megabytes or more of free memory
If necessary, please consult this document to setup swap: http://dokku.viewdocs.io/dokku/advanced-installation/#vms-with-less-than-1gb-of-memory
--> Ensuring we have the proper dependencies
--> Initial apt-get update
--> Installing docker
--> NOTE: Using Linode? Docker may complain about missing AUFS support.
    You can safely ignore this warning.
        Installation will continue in 10 seconds.
...

Vai all'indirizzo IP pubblico del tuo Linode in un browser e inserisci la chiave pubblica:

Attenzione Aggiungi la chiave pubblica subito dopo aver eseguito lo script di installazione per evitare che qualcun altro aggiunga una chiave pubblica a Dokku. Per un'installazione automatica, fare riferimento alle istruzioni di installazione avanzata.
Per aggiungere ulteriori chiavi SSH, invia l'output tramite SSH al dokku utente. Sostituisci example.com con l'indirizzo IP del tuo Linode.
```
cat ~/.ssh/id_rsa.pub | ssh [email protected] ssh-keys:add new-key
```

Crea un'applicazione Flask

Sul tuo computer locale, crea una nuova directory di progetto:
```
mkdir flask-example && cd flask-example
```

Crea un nuovo file chiamato hello_world.py che serve "Hello World!" nella pagina dell'indice.

File:hello_world .py

import os

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World!'

if __name__ == '__main__':
    # Bind to PORT if defined, otherwise default to 5000.
    port = int(os.environ.get('PORT', 5000))
    app.run(host='127.0.0.1', port=port)

Aggiungi un requirements.txt per tenere traccia delle versioni di eventuali dipendenze dell'applicazione Flask. Gunicorn è il server WSGI utilizzato per consentire a Flask di interfacciarsi correttamente con NGINX.
File:requisiti .txt
1 2

Flask==0.12.1 gunicorn==19.7.1
Per progetti più complessi con molte dipendenze che utilizzano un ambiente virtuale, reindirizza l'output di pip freeze in requirements.txt .
```
pip freeze > requirements.txt
```

Aggiungi un gitignore

Facoltativamente, aggiungi un .gitignore per fare in modo che Git ometta la memorizzazione nella cache e i file dell'ambiente virtuale dal controllo della versione.

File:. gitignore

__pycache__/
*.pyc

venv/

Procfile

Il Procfile dice al server Gunicorn quale comando utilizzare all'avvio dell'app:

File:Procfile

`1`	`web: gunicorn hello_world:app --workers=4`

Nota 4 worker è una buona impostazione predefinita per un'app Web in esecuzione su Linode. Consulta la documentazione di Gunicorn per ulteriori informazioni su come determinare il numero corretto di lavoratori per la tua particolare app.

Git Remote

Inizializza un repository Git:

git init
git add .
git commit -m "Deploy Flask with Dokku"

Aggiungi un telecomando chiamato dokku con il nome utente dokku e sostituisci example.com con l'indirizzo IP pubblico del tuo Linode:
```
git remote add dokku [email protected]:flask-example
```

Verifica che il telecomando sia stato aggiunto:

git remote -v

Questo elencherà i telecomandi.

dokku   [email protected]:flask-example (fetch)
dokku   [email protected]:flask-example (push)

In sintesi, il layout del progetto è simile a:

flask-example
├── .gitignore
├── Procfile
├── hello_world.py
└── requirements.txt

Crea progetto su un host Dokku

SSH nel tuo Linode e crea l'applicazione:
```
dokku apps:create flask-example
```
Assicurati che VHOST sia abilitato.
```
dokku domains:enable flask-example
```

Distribuisci un'applicazione Flask

Sul tuo computer locale, distribuisci l'applicazione Flask spingendo il ramo nel dokku a distanza. Questo si prenderà cura di NGINX dietro le quinte ed esporrà la porta 80 :
```
git push dokku master
```
È possibile distribuire anche altri rami locali, ma tutti i rami devono essere inviati al ramo principale del dokku telecomando:
```
git push dokku branch-name:master
```
curl l'indirizzo IP del tuo Linode per verificare che l'app sia stata distribuita correttamente:
```
curl example.com
```
```
Hello World!
```

Certificato SSL con Dokku e Let's Encrypt

I restanti passaggi di questa guida devono essere eseguiti dal tuo Linode.

Installa il plug-in Let's Encrypt per Dokku:

sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git

Imposta il DOKKU_LETSENCRYPT_EMAIL variabile di ambiente all'e-mail per Let's Encrypt:
```
dokku config:set flask-example [email protected]
```

Aggiungi l'applicazione e il dominio:

dokku domains:add flask-example example.com

Crea il certificato SSL. NGINX inizierà automaticamente a servire l'applicazione tramite HTTPS sulla porta 443:
```
 dokku letsencrypt flask-example
```
Eseguilo come cron job in modo che il certificato si rinnovi automaticamente:.
```
dokku letsencrypt:cron-job --add
```
Nota Ciò richiede Dokku versione 0.5 o successiva. Verifica eseguendo dokku version .

Avvia, arresta e riavvia le applicazioni

Elenca tutte le applicazioni Dokku in esecuzione:
```
  dokku apps
```
Riavvia un'applicazione:
```
  dokku ps:restart flask-example
```
Arresta un'applicazione:
```
  dokku ps:stop flask-example
```
Ripristina tutte le applicazioni dopo un riavvio:
```
  dokku ps:restore
```

Visualizza i registri dell'applicazione

Visualizza i registri dell'applicazione tramite Dokku o il contenitore Docker.

Per vedere i log tramite Dokku:
```
dokku logs flask-example
```
Elenca tutti i contenitori Docker in esecuzione:
```
sudo docker ps -a
```
Trova l'ID del contenitore, quindi esegui:
```
sudo docker logs container_id
```

Applicazioni scalabili

Dokku non ridimensiona automaticamente le applicazioni e per impostazione predefinita eseguirà solo un singolo web processi. Per aumentare il numero di contenitori che eseguono la tua applicazione, puoi utilizzare ps:scale comando.

Controlla quanti lavoratori ha attualmente la tua applicazione:

dokku ps:scale flask-example

-----> Scaling for flask-example
-----> proctype           qty
-----> --------           ---
-----> web                1

Scala fino a 4 web processi:
```
dokku ps:scale flask-example web=4
```

Conferma che i nuovi processi sono in esecuzione:

-----> Scaling for flask-example
-----> proctype           qty
-----> --------           ---
-----> web                4

Dokku è un'alternativa open source a Heroku per piccole applicazioni. La distribuzione di applicazioni è semplice come eseguire il push su un telecomando con Git. Elementi come Docker e NGINX vengono astratti per ridurre al minimo i tempi di implementazione. Ci sono funzionalità aggiuntive come hook pre-distribuzione e collegamento di database che non sono mostrati in questa guida.

Maggiori informazioni

Si consiglia di consultare le seguenti risorse per ulteriori informazioni su questo argomento. Sebbene questi siano forniti nella speranza che possano essere utili, tieni presente che non possiamo garantire l'accuratezza o la tempestività dei materiali ospitati esternamente.

Dokku PaaS
Boccetta

Strumentazione container con lo stack elastico

Accedi a un server Web Apache all'interno di un container LXD

Docker

Come distribuire Docker Compose Stack su Kubernetes con Kompose

Come distribuire un'applicazione API Python Flask su Docker

Come distribuire CouchDB come cluster con Docker

Come distribuire rapidamente applicazioni full-stack con i modelli di applicazione Portainer

Node.js cPanel:come distribuire un'app

Come distribuire l'applicazione Laravel con Nginx su Ubuntu?