Construisez FastAPI + uvicorn + nginx avec docker-compose

Cible

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

docker-compose.yml

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

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"]

pyproject.toml

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 / `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

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;
}

Courir

# `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)

image.png

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

image.png

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)

  1. Afficher la page Web avec FastAPI + uvicorn + Nginx (fonction Templates de Jinja2)
  2. Afficher la page Web avec FastAPI + uvicorn + Nginx (SSL / HTTPS)

Recommended Posts

Construisez FastAPI + uvicorn + nginx avec docker-compose
Créez un environnement de développement Django avec Docker! (Docker-compose / Django / postgreSQL / nginx)
Afficher la page Web avec FastAPI + uvicorn + Nginx (conversion SSL / HTTPS)
Créez un environnement d'API rapide avec docker-compose
Construire un environnement de NGINX + NGINX Unit + MySQL avec Docker
Afficher une page Web avec FastAPI + uvicorn + Nginx (fonction Modèles de Jinja2)
environnement python avec docker-compose
Construisez python3.x avec pyenv
Créer un environnement django avec docker-compose (MariaDB + Nginx + uWSGI)
[blackbird-nginx] Surveiller Nginx avec blackbird
API avec Flask + uWSGI + Nginx
Contrôler le libellé des erreurs avec nginx
Créer un environnement python3 avec ubuntu 16.04
Combinez Fast API avec Django ORM
Construire un environnement python avec direnv
Créez facilement des CNN avec Keras
Construisons git-cat avec Python
Construction de l'environnement de développement Django avec Docker-compose + Nginx + uWSGI + MariaDB (édition macOS)
[DynamoDB] [Docker] Créer un environnement de développement pour DynamoDB et Django avec docker-compose