Ziel

Veröffentlichen Sie mit Docker-Compose die FastAPI-App (mit uvicorn gestartet) auf http von Nginx 'Reverse Proxy
Veröffentlichen Sie zunächst ohne Authentifizierung auf http (80 Port)

Dateiorganisation

`Shell (Bash usw.)`


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

--FastAPI-Apps erstellen Bilder mit app / Dockerfile

In app / app gespeicherter Quellcode
Die Python-Paketverwaltung verwendet bei Bedarf "pyproject.toml" und "Poetry.lock" (unter Verwendung von Poetry).
(Es gibt keinen tiefen Grund, daher können Sie dies problemlos mit pip + require.txt tun Verwenden Sie Pipenv oder miniconda Ich denke, es gibt verschiedene Möglichkeiten. --Nginx wird in web / conf.d / app.conf gesetzt

docker-compose.yml

Übersicht über die Systemkonfiguration

`docker-compose.yml`


version: '3'

services:
  web:
    container_name: web
    image: nginx:alpine
    depends_on:
      # `app`Weil der Dienst (Container) zuerst gestartet werden muss`depends_on`Angegeben
      - app
    ports:
      #Port-Mapping:"Host-Betriebssystem-Port:Container(Nginx)Hafen"
      - "80:80"
    volumes:
      #Volume Mount:"Pfad des Host-Betriebssystems:Pfad im Container"
      - ./web/conf.d:/etc/nginx/conf.d
    networks:
      - nginx_network

  app:
    container_name: app
    image: test_fastapi_app #Geben Sie den Namen des zu erstellenden Docker-Images an
    build:
      context: ./app
      dockerfile: Dockerfile
    expose:
      - 8000
    networks:
      - nginx_network
    #Zum Beispiel, wenn Sie den Quellcode in Echtzeit bearbeiten möchten`volumes`Bequem zu montieren
    # volumes:
    #   - ./app/app:/app/app
    #des App-Containers`CMD`Zu überschreiben`command`verwenden
    # command: "uvicorn app.main:app --reload --host 0.0.0.0"

networks:
  nginx_network:
    driver: bridge

Der Nginx-Container "web" und der FastAPI-App-Container "app" werden separat erstellt und durch Docker-Compose-Netzwerke verbunden: "nginx_network".
Das Nginx-Bild verwendet eine leichte alpine Version

Details des Inhalts von "App" und "Web" werden später beschrieben.

`app` (FastAPI-App-Body)

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

#Allgemeines Benutzerkonto hinzufügen
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

#Kopieren Sie FastAPI-Quellcode usw. in den Container
COPY ./app /app/app
COPY ./pyproject.toml /app/pyproject.toml
#Poesie in der lokalen Umgebung verwendet.Fügen Sie gegebenenfalls die Sperrdatei hinzu
# 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/*

#Platzieren Sie den PFAD in der von Poetry erstellten virtuellen Umgebung (stellen Sie die Poetry-Konfiguration im Voraus ein, um den PFAD der virtuellen Umgebung eindeutig zu machen).
ENV PATH=/app/.venv/bin:$PATH

# Configration
EXPOSE 8000

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

Verwenden Sie vorerst die Version 3.8 von Python (unter Verwendung des Tags der slim-buster-Serie (debian-basiert) des offiziellen Bildes).
Da es auf Debian basiert, installieren Sie die erforderlichen Bibliotheken mit apt
Ich persönlich möchte nicht als Root-Benutzer starten, also erstelle einen Benutzer, um die App zu starten
tini funktioniert ohne, aber es scheint besser, es beim Starten des Containers zu verwenden, also [Erklärung auf GitHub](https: // github) .com / krallin / tini # using-tini)
Eine Reihe von Dateien für FastAPI-Apps wird im Verzeichnis / app des Containers gespeichert und als Arbeitsbereich verwendet.
Der Hauptteil des Quellcodes ist "/ app / app" --Installieren der erforderlichen Pakete mithilfe von "Poetry" mit lokalen Benutzerrechten --poetry config virtualenvs.in-project true ermöglicht die Erstellung einer virtuellen Umgebung in / app / .venv
Wenn Sie eine poetry.lock-Datei für die Entwicklung in einer lokalen Umgebung haben, können Sie das zu installierende Paket reparieren, indem Sie # COPY ./poetry.lock / app / poet.lock auskommentieren.

pyproject.toml

Informationen zu zu installierenden Paketen usw.
Die minimal erforderlichen Paketinformationen sind in "tool.poetry.dependencies" beschrieben, der Rest ist angemessen.
(Ergänzungen und Korrekturen werden nach Bedarf unter Bezugnahme auf Offizielle Dokumente usw. vorgenommen.)

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

FastAPI App

―― Bereiten Sie diesmal nur das Minimum vor

app / app / main.py sieht folgendermaßen aus:

`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 ist eine leere Datei)

Die folgende "App / App /" wird in Zukunft je nach Zweck und Notwendigkeit des jeweiligen Anlasses erstellt.

uvicorn

Verwenden Sie uvicorn (Offizielle Dokumentation), um die FastAPI-App zu starten.

uvicorn app.main:app --host 0.0.0.0

Machen. (Beachten Sie, dass sich auch der Teil app.main: app ändern sollte, wenn sich der Verzeichnisname oder der Dateiname ändert.) Optional: --host 0.0.0.0 ist erforderlich, damit der auf dem Container ausgeführte uvicorn-Server extern angezeigt werden kann. Der uvicorn-Server startet standardmäßig auf Port 8000, führen Sie also "EXPOSE 8000" usw. auf "Dockerfile" oder "docker-compose.yml" aus. (Vielleicht habe ich es nicht gebraucht)

Wenn Sie die Option "--reload" hinzufügen, erkennt der uvicorn-Server, wann die Datei geändert wird, und startet sie neu, was für die Entwicklung usw. praktisch ist.

`web` (Webserver von Nginx)

--Reverse Proxy des Uvicorn-Servers, der im App-Container ausgeführt wird

Verschiedene Einstellungen können vorgenommen werden, indem Einstellungen in /etc/nginx/conf.d / ***. Conf geschrieben werden
Es scheint, dass der Name "***. Conf" alles sein kann (diesmal "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;
}

Der Reverse Proxy von "App: 8000" ist auf "Upstream" eingestellt.
Ich glaube, dass "App" hier dem Dienstnamen entspricht, der auf "docker-compose.yml" geschrieben ist (es tut mir leid, wenn es anders ist)
Der Inhalt von app: 8000 wird unter / von Nginx atlocation /veröffentlicht.
Wenn Sie auf Port 80 von Nginx zugreifen, können Sie daher den Inhalt sehen, der von Port 8000 von FastAPI (uvicorn) veröffentlicht wurde.
Wenn Sie einen Servernamen oder eine Protokollausgabe benötigen, kommentieren Sie den entsprechenden Teil entsprechend aus.

Lauf

Häufig verwendete Gegenstände:

# `app`Erstellen Sie ein Image von
docker-compose build

#Starten Sie den gesamten Dienst
docker-compose up -d

#Wenn Sie fertig sind
docker-compose down

#Überprüfen Sie die Konsolenausgabe
docker-compose logs
docker-compose logs app #Überprüfen Sie nur das App-Service-Protokoll

#Gehe in den App-Container
docker-compose run app bash

Wenn die Einstellungen korrekt sind, können Sie "docker-compose up -d" ausführen, um auf http: // localhost und http: // localhost / docs usw. zuzugreifen.

--http: // localhost (wenn in lokaler Umgebung ausgeführt)

--http: // localhost / docs (wenn in lokaler Umgebung ausgeführt)

Sie können den Bildschirm wie sehen. Wenn Sie in einer Remote-Umgebung wie EC2 unter AWS ausgeführt werden, sollte es in Ordnung sein, wenn Sie "localhost" durch die Adresse des ausgeführten Computers ersetzen.

Zusammenfassung

Ich habe eine titelähnliche Struktur mit möglichst geringem Inhalt erstellt. Diesmal habe ich dies nicht getan, aber Sie können Nginx für die SSL- (HTTPS-Kommunikation) und BASIC-Authentifizierung verwenden. → Außerdem war ich bei Verwendung der Vorlagenfunktion von Jinja2 ziemlich süchtig nach SSL-Konvertierung (https wurde zu http, Portnummerninformationen fehlten, wenn ein anderer als der Standardport verwendet wurde, und die Verknüpfungsfunktion war nicht verfügbar. Es hat nicht gut funktioniert), also werde ich es separat zusammenfassen ~~. (↓ unten)

[PYTHON] Erstellen Sie FastAPI + uvicorn + nginx mit Docker-Compose

Ziel

Dateiorganisation

Shell (Bash usw.)

docker-compose.yml

app (FastAPI-App-Body)