FastAPI vers Base de données relationnelle

Le générateur connection relie un projet FastAPI à un projet Python Relational Database, en injectant une session SQLModel typée dans vos gestionnaires de routes via une dépendance FastAPI.

Prérequis

Avant d’utiliser ce générateur, assurez-vous d’avoir :

1. Un projet FastAPI (généré avec py#api --framework=fastapi), voir le guide py#api
2. Un projet py#rdb

Utilisation

Exécuter le générateur

Exécuter ce générateur@aws/nx-plugin:connection

CLI

pnpm

$ pnpm nx g @aws/nx-plugin:connection

yarn

$ yarn nx g @aws/nx-plugin:connection

npm

$ npx nx g @aws/nx-plugin:connection

bun

$ bunx nx g @aws/nx-plugin:connection

VSCode

1. Installez le Nx Console VSCode Plugin si ce n'est pas déjà fait
2. Ouvrez la console Nx dans VSCode
3. Cliquez sur Generate (UI) dans la section "Common Nx Commands"
4. Recherchez @aws/nx-plugin - connection
5. Remplissez les paramètres requis
6. Cliquez sur Generate

Composez votre commande5

sourceProjectRequis

targetProjectRequis

sourceComponent

targetComponent

preferInstallDependencies

true

--dry-runVous pouvez également effectuer une simulation pour voir quels fichiers seraient modifiés

Sélectionnez votre projet FastAPI comme source et votre projet de base de données relationnelle comme cible.

Options

Options du générateur5 options

sourceProjectRequisstring

Le projet source

targetProjectRequisstring

Le projet cible auquel se connecter

sourceComponentstring

Le composant source depuis lequel se connecter (nom du composant, chemin relatif à la racine du projet source, ou identifiant de générateur). Utilisez '.' pour sélectionner explicitement le projet comme source.

targetComponentstring

Le composant cible auquel se connecter (nom du composant, chemin relatif à la racine du projet cible, ou identifiant de générateur). Utilisez '.' pour sélectionner explicitement le projet comme cible.

preferInstallDependenciesbooleanPar défaut: true

Indique s'il faut privilégier l'installation des dépendances après l'exécution du générateur. Définir à false pour différer l'installation lors de l'exécution de plusieurs générateurs en lot (une installation s'exécute quand même si nécessaire pour que les générateurs suivants puissent calculer le graphe de projet Nx) ; installer une seule fois à la fin.

Sortie du générateur

Le générateur modifie votre projet FastAPI :

• Répertoirepackages/my_api

  • project.json Ajoute une dépendance de dev sur la cible dev de la base de données
  • pyproject.toml Ajoute le package de base de données comme dépendance d’espace de travail
  • Répertoiremy_api

    • Répertoiredependencies

      • my_db.py Dépendance FastAPI MyDbSession pour la session de base de données

Utiliser la base de données dans les gestionnaires de routes

Ce générateur configure une dépendance FastAPI injectable que vous pouvez utiliser dans vos gestionnaires de routes :

packages/my_api/my_api/api.py

from sqlmodel import select
from my_api.dependencies.my_db import MyDbSession
from my_scope_my_db.models.example import ExampleModel

@app.get("/examples")
async def list_examples(my_db: MyDbSession):
    return (await my_db.execute(select(ExampleModel))).scalars().all()

@app.post("/examples")
async def create_example(name: str, my_db: MyDbSession):
    item = ExampleModel(name=name)
    my_db.add(item)
    await my_db.commit()
    await my_db.refresh(item)
    return item

FastAPI ouvre automatiquement une nouvelle session par requête et la ferme lorsque le gestionnaire retourne.

Infrastructure

Pour permettre à la fonction Lambda FastAPI de se connecter à la base de données lors de l’exécution, elle doit être déployée dans le même VPC que la base de données et bénéficier d’un accès réseau et IAM.

CDK

Dans votre stack d’application, déployez l’API dans le même VPC que la base de données, puis appelez allowDefaultPortFrom et grantConnect pour ouvrir le chemin réseau et accorder la permission IAM rds-db:connect au gestionnaire Lambda :

packages/infra/src/stacks/application-stack.ts

import { MyDatabase } from '@my-scope/common-constructs';

const db = new MyDatabase(this, 'Db', { vpc, ... });

const api = new MyApi(this, 'Api', {
  integrations: MyApi.defaultIntegrations(this)
    .withDefaultOptions({
      vpc,
      vpcSubnets: { subnetType: SubnetType.PRIVATE_WITH_EGRESS },
    })
    .build(),
});

Object.entries(api.integrations).forEach(([operation, integration]) => {
  db.allowDefaultPortFrom(integration.handler, `Allow ${operation} to connect to the database`);
  db.grantConnect(integration.handler);
});

Déployez les fonctions Lambda de l’API dans un sous-réseau privé avec sortie, et non dans un sous-réseau privé isolé. Lors de l’exécution, session_context() récupère la configuration de la base de données depuis AWS AppConfig, qui est un point de terminaison de service AWS public nécessitant un accès Internet sortant.

Note

Cet exemple accorde à chaque gestionnaire de votre API un accès, mais si seuls certains gestionnaires ont besoin d’accès, il est préférable de configurer individuellement.

Terraform

Déployez l’API dans le même VPC que la base de données, accordez-lui rds-db:connect via additional_iam_policy_statements, et ouvrez le chemin réseau avec une paire de règles de groupe de sécurité :

L’exemple ci-dessous fait référence aux ressources VPC du guide de déploiement Python Relational Database : les sous-réseaux aws_subnet.database n’ont pas de route Internet, tandis que les sous-réseaux aws_subnet.private ont une sortie NAT.

packages/infra/src/main.tf

module "my_database" {
  source              = "../../common/terraform/src/app/dbs/my-database"
  vpc_id              = aws_vpc.main.id
  database_subnet_ids = aws_subnet.database[*].id
  lambda_subnet_ids   = aws_subnet.private[*].id
}

module "api" {
  source     = "../../common/terraform/src/app/apis/my-api"
  enable_vpc = true
  vpc_id     = aws_vpc.main.id
  subnet_ids = aws_subnet.private[*].id

  appconfig_application_id  = module.runtime_config_appconfig.application_id
  appconfig_application_arn = module.runtime_config_appconfig.application_arn

  additional_iam_policy_statements = [
    {
      Effect = "Allow"
      Action = ["rds-db:connect"]
      Resource = [
        "arn:aws:rds-db:${data.aws_region.current.region}:${data.aws_caller_identity.current.account_id}:dbuser:${module.my_database.connect_resource_id}/${module.my_database.database_runtime_user}"
      ]
    }
  ]
}

resource "aws_vpc_security_group_ingress_rule" "api_to_database" {
  description                  = "Allow the API Lambda functions to connect to the database"
  security_group_id            = module.my_database.security_group_id
  referenced_security_group_id = module.api.security_group_id
  from_port                    = module.my_database.cluster_port
  to_port                      = module.my_database.cluster_port
  ip_protocol                  = "tcp"
}

resource "aws_vpc_security_group_egress_rule" "api_to_database" {
  description                  = "Allow outbound traffic from the API Lambda functions to the database"
  security_group_id            = module.api.security_group_id
  referenced_security_group_id = module.my_database.security_group_id
  from_port                    = module.my_database.cluster_port
  to_port                      = module.my_database.cluster_port
  ip_protocol                  = "tcp"
}

Déployez les fonctions Lambda de l’API dans des sous-réseaux privés avec sortie, et non dans des sous-réseaux privés isolés. appconfig_application_id/appconfig_application_arn proviennent de l’application AppConfig de configuration d’exécution partagée déclarée une fois dans votre module racine, et non du module de base de données — les transmettre définit RUNTIME_CONFIG_APP_ID sur les fonctions Lambda et leur accorde un accès en lecture à l’application.

L’application AppConfig expose l’espace de noms database par défaut, de sorte que l’entrée de configuration d’exécution du module de base de données est déployée sans configuration supplémentaire.

Exigences SSL lors de la connexion sans RDS Proxy

Le magasin de confiance CA intégré de l’environnement d’exécution Lambda Amazon Linux 2023 inclut les CA racine Amazon utilisés par RDS, aucune configuration supplémentaire n’est donc nécessaire.

Lors de l’utilisation de RDS Proxy, vous n’avez pas besoin de configurer le bundle CA RDS dans votre fonction Lambda.

Développement local

pnpm

pnpm nx dev <project-name>

yarn

yarn nx dev <project-name>

npm

npx nx dev <project-name>

bun

bunx nx dev <project-name>

Cela démarre la FastAPI et toutes les bases de données connectées. La variable d’environnement LOCAL_DEV=true fait en sorte que le client de base de données se connecte à sa base de données Docker locale au lieu d’Aurora.