Cible

À l'aide de docker-compose, publiez l'application FastAPI (lancée avec uvicorn) sur http par le proxy inverse de Nginx
Tout d'abord, publier sur http (80 ports) sans authentification

organisation des fichiers

`shell (bash, etc.)`


$ tree  
.
├── app
│   ├── Dockerfile
│   ├── app
│   │   ├── __init__.py
│   │   └── main.py
│   ├── poetry.lock
│   └── pyproject.toml
├── docker-compose.yml
└── web
    └── conf.d
        └── app.conf

L'application Fast API crée une image en utilisant ʻapp / Dockerfile`
Code source stocké dans ʻapp / app`
La gestion des paquets Python utilise pyproject.toml et poetry.lock si nécessaire (en utilisant Poetry)
(Il n'y a pas de raison profonde, vous pouvez donc le faire facilement avec pip + requirements.txt Utilisez Pipenv ou miniconda Je pense qu'il y a plusieurs façons) --Nginx est défini dans web / conf.d / app.conf

docker-compose.yml

Vue d'ensemble de la configuration du système

`docker-compose.yml`


version: '3'

services:
  web:
    container_name: web
    image: nginx:alpine
    depends_on:
      # `app`Parce que le service (conteneur) doit être démarré en premier`depends_on`Est spécifié
      - app
    ports:
      #Cartographie des ports:"Port du système d'exploitation hôte:récipient(Nginx)Port"
      - "80:80"
    volumes:
      #montage du volume:"Chemin du système d'exploitation hôte:Chemin dans le conteneur"
      - ./web/conf.d:/etc/nginx/conf.d
    networks:
      - nginx_network

  app:
    container_name: app
    image: test_fastapi_app #Spécifiez le nom de l'image Docker à créer
    build:
      context: ./app
      dockerfile: Dockerfile
    expose:
      - 8000
    networks:
      - nginx_network
    #Par exemple, si vous souhaitez éditer le code source en temps réel`volumes`Pratique à monter avec
    # volumes:
    #   - ./app/app:/app/app
    #du conteneur d'application`CMD`Pour écraser`command`utilisation
    # command: "uvicorn app.main:app --reload --host 0.0.0.0"

networks:
  nginx_network:
    driver: bridge

Le conteneur Nginx web et le conteneur d'application FastAPI ʻapp sont créés séparément et connectés par des réseaux docker-compose: nginx_network`.
L'image nginx utilise une version alpine légère

Les détails du contenu de «app» et «web» seront décrits plus loin.

ʻApp` (corps de l'application Fast API)

Dockerfile

`Dockerfile`


ARG BASE_IMAGE=python:3.8-slim-buster                                                                                
FROM $BASE_IMAGE                                                                                                     
                                                                                                                     
# system update & package install                                                                                    
RUN apt-get -y update && \                                                                                           
    apt-get install -y --no-install-recommends \                                                                     
    build-essential \                                                                                                
    openssl libssl-dev \                                                                                             
    && apt-get clean \                                                                                               
    && rm -rf /var/lib/apt/lists/*                                                                                   
                                                                                                                     
# Add Tini                                                                                                           
ENV TINI_VERSION v0.19.0
ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /tini
RUN chmod +x /tini
ENTRYPOINT ["/tini", "--"]

#Ajouter un compte d'utilisateur général
ARG USER_NAME=app
ARG USER_UID=1000
ARG PASSWD=password

RUN useradd -m -s /bin/bash -u $USER_UID $USER_NAME && \
    gpasswd -a $USER_NAME sudo && \
    echo "${USER_NAME}:${PASSWD}" | chpasswd && \
    echo "${USER_NAME} ALL=(ALL) ALL" >> /etc/sudoers

#COPIER le code source FastAPI, etc. dans le conteneur
COPY ./app /app/app
COPY ./pyproject.toml /app/pyproject.toml
#Poésie utilisée dans l'environnement local.Ajoutez le fichier de verrouillage, le cas échéant
# COPY ./poetry.lock /app/poetry.lock
RUN chown -R ${USER_NAME}:${USER_NAME} /app


USER $USER_NAME
WORKDIR /app
# pip & poetry
ENV PATH $PATH:/home/${USER_NAME}/.local/bin
RUN python3 -m pip install --user --upgrade pip && \
    python3 -m pip install poetry --user && \
    poetry config virtualenvs.in-project true && \
    poetry install && \
    rm -rf ~/.cache/pip/* && \
    rm -rf ~/.cache/pypoetry/*

#Placez le PATH dans l'environnement virtuel créé par Poetry (définissez la configuration de poésie à l'avance pour rendre le PATH de l'environnement virtuel unique)
ENV PATH=/app/.venv/bin:$PATH

# Configration
EXPOSE 8000

# Execute
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0"]

Pour le moment, utilisez la version 3.8 de Python (en utilisant la balise de la série slim-buster (basée sur Debian) de l'image officielle) --Parce qu'il est basé sur Debian, installez les bibliothèques nécessaires avec ʻapt`
Personnellement, je ne veux pas commencer en tant qu'utilisateur root, alors créez un utilisateur pour démarrer l'application
tini fonctionne sans lui, mais il semble préférable de l'utiliser lors du démarrage du conteneur, donc [Explication sur GitHub](https: // github) .com / krallin / tini # using-tini)
Un ensemble de fichiers pour les applications FastAPI est stocké dans le répertoire / app du conteneur et utilisé comme espace de travail.
Le corps du code source est / app / app --Installation des packages requis en utilisant Poetry avec des privilèges d'utilisateur local --poetry config virtualenvs.in-project true permet de créer un environnement virtuel dans / app / .venv
Si vous avez un fichier poetry.lock pour le développement dans un environnement local, vous pouvez corriger le paquet à installer en décommentant # COPY ./poetry.lock / app / poetry.lock.

pyproject.toml

Informations sur les packages à installer, etc.
Les informations minimales requises sur le paquet sont décrites dans tool.poetry.dependencies, et le reste est approprié.
(Les ajouts et corrections seront effectués en se référant aux Documents officiels etc. si nécessaire)

`pyproject.toml`


[tool.poetry]
name = "test_fastapi_app"
version = "0.1.0"
description = "just for test"
authors = ["Your Name <[email protected]>"]

[tool.poetry.dependencies]
python = "^3.8"
uvicorn = "*"
fastapi = "*"

[build-system]
requires = ["poetry>=0.12"]
build-backend = "poetry.masonry.api"

Application FastAPI

――Cette fois, ne préparez que le minimum

ʻApp / app / main.py` ressemble à ceci:

`main.py`


"""
app main
"""

from fastapi import FastAPI

app = FastAPI()


@app.get('/')
async def site_root():
    """root"""
    return {"message": "Hello, WORLD!"}

(ʻApp / app / __ init __. Py` est un fichier vide)

ʻApp / app / `Les éléments suivants seront créés à l'avenir en fonction du but et de la nécessité de chaque occasion.

uvicorn

Pour lancer l'application FastAPI, utilisez ʻuvicorn` (Official Document)

uvicorn app.main:app --host 0.0.0.0

Faire. (Notez que si le nom du répertoire ou le nom du fichier change, la partie de ʻapp.main: appdevrait également changer.) Facultatif:--host 0.0.0.0 est requis pour permettre au serveur uvicorn exécuté sur le conteneur d'être vu de l'extérieur. Le serveur uvicorn démarre sur le port 8000 par défaut, alors faites quelque chose comme ʻEXPOSE 8000 sur Dockerfile ou docker-compose.yml. (Peut-être que je n'en avais pas besoin)

Si vous ajoutez l'option --reload, le serveur uvicorn détectera quand le fichier est modifié et le redémarrera, ce qui est pratique pour le développement, etc.

`web` (serveur Web par Nginx)

--ʻApp` Proxy inverse du serveur uvicorn fonctionnant dans le conteneur

Différents paramètres peuvent être définis en écrivant les paramètres dans /etc/nginx/conf.d / ***. Conf --Il semble que le nom de ***. Conf puisse être n'importe quoi (cette fois, c'est ʻapp.conf`).

`app.conf`


upstream backend {
    server app:8000;
}

server {
    listen 80;
    # server_name  localhost;

    location / {
        proxy_pass http://backend;
    }

    # log
    # access_log /var/log/nginx/access.log;
    # error_log /var/log/nginx/error.log;
}

Le proxy inverse de ʻapp: 8000 est défini sur ʻupstream.
Je pense que ʻapp correspond ici au nom du service écrit sur docker-compose.yml(je suis désolé si c'est différent) --Àlocation /, le contenu de ʻapp: 8000 est publié sous` / ʻ de Nginx.
En conséquence, lorsque vous accédez au port 80 de Nginx, vous pouvez voir le contenu publié par le port 8000 de FastAPI (uvicorn). --Si vous avez besoin de nom_serveur ou d'une sortie de journal, commentez la partie appropriée si nécessaire.

Courir

Articles fréquemment utilisés:

# `app`Construire l'image de
docker-compose build

#Démarrez tout le service
docker-compose up -d

#Une fois terminé
docker-compose down

#Vérifiez la sortie de la console
docker-compose logs
docker-compose logs app #Vérifier uniquement le journal du service d'application

#Allez dans le conteneur de l'application
docker-compose run app bash

Si les paramètres sont corrects, vous pouvez faire docker-compose up -d pour accéder à http: // localhost et http: // localhost / docs, etc.

--http: // localhost (lors de l'exécution dans l'environnement local)

--http: // localhost / docs (lors de l'exécution dans l'environnement local)

Vous pouvez voir l'écran comme. Lors de l'exécution dans un environnement distant tel qu'EC2 sur AWS, cela devrait être OK si vous remplacez localhost par l'adresse de la machine en cours d'exécution.

Résumé

J'ai créé une structure semblable à un titre avec le moins de contenu possible. Je ne l'ai pas fait cette fois, mais vous pouvez utiliser Nginx pour SSL (communication HTTPS) et l'authentification BASIC. → De plus, lors de l'utilisation de la fonction Template de Jinja2, j'étais assez accro à la conversion SSL (https est devenu http, les informations de numéro de port manquaient lors de l'utilisation d'un port autre que celui par défaut, et la fonction de lien n'était pas disponible. Cela n'a pas bien fonctionné), je vais donc le résumer séparément ~~. (↓ ci-dessous)

Construisez FastAPI + uvicorn + nginx avec docker-compose