Unité 4.2 : Object Storage Intégration

Introduction

TaskBoard permet aux utilisateurs d'attacher des fichiers aux tâches : captures d'écran, PDF, maquettes de conception, et occasionnellement des vidéos de plusieurs gigaoctets. Vous ne voulez pas que ces octets passent par votre API processus. Ils consomment de la mémoire, bloquent les threads de travail, et transforment un API sans état en un goulet d'étranglement. La solution est IONOS Cloud Object Storage avec des URL pré-signées : le navigateur communique directement avec Object Storage, et votre API ne gère que de petits enregistrements de métadonnées.

Dans cette unité, vous connectez le API TaskBoard à Object Storage via le S3-compatible API en utilisant boto3. La chose la plus importante à retenir dès le départ : Object Storage n'utilise pas votre jeton IONOS Cloud. Il s'authentifie avec une paire de clé d'accès et de clé secrète distincte, exactement comme AWS S3. Vous allez configurer le client, générer des URL de téléchargement et de téléchargement pré-signées, gérer les grands fichiers avec un téléchargement multipart, et appliquer des règles de cycle de vie pour que les téléchargements abandonnés ne s'accumulent pas à jamais.

1. Authentification et connexion avec boto3

Object Storage expose une surface v2 d'AWS S3 API, donc les SDK AWS standard fonctionnent avec lui. Ce qui change, c'est le point de terminaison et les informations d'identification. Vous devez passer un endpoint_url explicite (le SDK par défaut est AWS, et non IONOS) et une paire de clés d'accès et de clé secrète. Ces clés ne sont pas votre jeton d'accès Cloud API et ne sont pas un rôle IAM. Elles sont générées séparément et authentifient chaque demande S3 via la signature AWS.

Object Storage authentifie les utilisateurs avec une paire de clés : une clé d'accès et une clé secrète. Une clé doit être générée manuellement, soit dans le DCD sous Object Storage Informations d'identification et gestion, soit via le Object Storage Gestion API. La longueur actuelle de la clé d'accès est de 92 caractères et la longueur de la clé secrète est de 64 caractères, donc n'assumez pas de largeur de champ figée à partir de formats plus anciens de 20/40 caractères. Chaque utilisateur peut détenir jusqu'à 5 clés d'accès.

1.1 Construction du client S3

Avant d'écrire le code client, fixez la version de boto3 : boto3 1.36.0 et les versions ultérieures échouent chaque appel PutObject contre IONOS Object Storage avec InvalidTrailer (« Noms d'en-tête de fin de traînée non valides dans x-amz-trailer ») car IONOS ne prend pas en charge l'extension de vérification de somme de contrôle AWS que boto3 a introduite à partir de la version 1.36.0. Installez boto3<=1.35.99, ou si vous avez besoin d'une version plus récente de boto3, définissez les variables d'environnement AWS_REQUEST_CHECKSUM_CALCULATION=when_required et AWS_RESPONSE_CHECKSUM_VALIDATION=when_required avant chaque chemin de téléchargement dans cette unité (téléchargement pré-signé PUT, upload_file, upload_fileobj, multipart) qui fonctionnera.

Sélectionnez le point de terminaison pour la région où se trouve votre bucket. Le nom d'hôte du point de terminaison encode la région, et le SDK dérive la région de signature à partir de celui-ci, vous pouvez donc laisser le region_name minimal et laisser le point de terminaison diriger l'acheminement.

import boto3
from botocore.config import Config

s3 = boto3.client(
    "s3",
    endpoint_url="https://s3.eu-central-1.ionoscloud.com",  # Frankfurt (de)
    aws_access_key_id="YOUR_ACCESS_KEY",       # 92-char Object Storage key
    aws_secret_access_key="YOUR_SECRET_KEY",   # 64-char Object Storage secret
    region_name="eu-central-1",
    config=Config(signature_version="s3v4"),
)

# Smoke test: list buckets you own
for b in s3.list_buckets()["Buckets"]:
    print(b["Name"], b["CreationDate"])

Ne jamais intégrer les informations d'identification dans le code source. Les extraire des variables d'environnement ou d'un gestionnaire de secrets. Dans TaskBoard, la clé d'accès et la clé secrète proviennent de l'état Terraform (la ressource ionoscloud_s3_key de l'unité 2.4) et sont injectées comme secrets Kubernetes.

import os

s3 = boto3.client(
    "s3",
    endpoint_url=os.environ["OBJSTORAGE_ENDPOINT"],
    aws_access_key_id=os.environ["OBJSTORAGE_ACCESS_KEY"],
    aws_secret_access_key=os.environ["OBJSTORAGE_SECRET_KEY"],
    region_name=os.environ.get("OBJSTORAGE_REGION", "eu-central-1"),
    config=Config(signature_version="s3v4"),
)

1.2 Choix du point de terminaison régional approprié

Le point de terminaison n'est pas interchangeable. Un bucket existe dans exactement une région, et vous devez l'adresser via le point de terminaison de cette région. Object Storage est disponible à Berlin, Francfort, Logroño et Lenexa. Le tableau suivant mappe les centres de données à leurs régions et points de terminaison S3 :

Choisissez une région proche de votre application et de vos utilisateurs pour réduire la latence, et une région géographiquement séparée pour les sauvegardes afin qu'une panne locale ne supprime pas vos données principales. Notez les deux types de buckets : les buckets appartenant à l'utilisateur vivent dans de, eu-central-2, et eu-south-2, tandis que les buckets appartenant au contrat vivent dans eu-central-4, eu-central-3, et us-central-1. Les limites diffèrent selon le type : un utilisateur peut détenir jusqu'à 500 buckets appartenant à l'utilisateur et jusqu'à 1000 buckets appartenant au contrat. Le plafond de téléchargement en une seule demande est de 4,65 Go pour les buckets appartenant à l'utilisateur et de 5 Go pour les buckets appartenant au contrat, ce qui est le déclencheur pratique du téléchargement multipartite couvert à la section 3.

2. Opérations de bucket et URL pré-signées

Avec un client en main, les opérations quotidiennes sont standard S3 : créer un bucket, lister les objets, définir les ACL, et générer des URL pré-signées. Pour TaskBoard, les URL pré-signées sont au centre. Elles permettent au navigateur de télécharger et de téléverser des pièces jointes directement contre Object Storage, de sorte que votre API n'a jamais à diffuser les octets.

Par défaut, les objets sont privés et seul le propriétaire du bucket peut y accéder. Une URL pré-signée accorde un accès limité dans le temps à un seul objet sans modifier les autorisations de l'objet et sans partager vos clés. Le propriétaire signe l'URL, la transmet au client, et le client l'utilise jusqu'à son expiration.

2.1 Création de buckets et liste d'objets

Les noms de bucket sont uniques à l'échelle mondiale sur tout Object Storage, doivent être compris entre 3 et 63 caractères, et suivre les règles de nommage DNS. Les clés d'objets peuvent avoir jusqu'à 1024 caractères.

bucket = "taskboard-attachments-prod"

# Create the bucket (idempotent-ish: catch the "already owned" case)
try:
    s3.create_bucket(Bucket=bucket)
except s3.exceptions.BucketAlreadyOwnedByYou:
    pass

# List objects under a prefix, paginated (collections can be huge)
paginator = s3.get_paginator("list_objects_v2")
for page in paginator.paginate(Bucket=bucket, Prefix="task-42/"):
    for obj in page.get("Contents", []):
        print(obj["Key"], obj["Size"])

Il est toujours recommandé de paginer les listes. Un seul bucket peut contenir jusqu'à 200 000 000 d'objets dans le cas non versionné, donc une liste non paginée sera tronquée silencieusement à la première page.

2.2 URL de téléchargement et de téléversement pré-signées

Générez une URL PUT pré-signée pour que le navigateur téléverse le fichier directement. Votre API renvoie l'URL et la clé de l'objet ; il ne voit jamais le contenu du fichier.

def presign_upload(key: str, content_type: str, expires: int = 900) -> str:
    return s3.generate_presigned_url(
        "put_object",
        Params={"Bucket": bucket, "Key": key, "ContentType": content_type},
        ExpiresIn=expires,  # seconds; keep short for uploads
    )

def presign_download(key: str, expires: int = 300) -> str:
    return s3.generate_presigned_url(
        "get_object",
        Params={"Bucket": bucket, "Key": key},
        ExpiresIn=expires,
    )

Le navigateur téléverse ensuite avec une requête HTTP simple à l'URL signée. Le Content-Type doit correspondre à ce qui a été signé, sinon la vérification de la signature échoue :

await fetch(presignedUrl, {
  method: "PUT",
  headers: { "Content-Type": file.type },
  body: file,
});

Les URL pré-signées sont idéales pour permettre à d'autres utilisateurs de téléverser des objets directement dans votre bucket sans jamais leur donner votre Clé d'accès et votre Clé secrète. Elles sont également l'outil approprié pour partager un objet privé avec quelqu'un qui n'a pas de compte IONOS : l'URL fonctionne pour la fenêtre configurée, puis expire. Les signatures v2 et v4 sont prises en charge ; utilisez la v4.

3. Modèles de téléchargement et de téléchargement de fichiers

Les petites pièces jointes sont un seul put_object. Les pièces jointes plus importantes nécessitent un téléchargement multipart, à la fois pour dépasser le plafond de taille de requête unique et pour télécharger des parties en parallèle pour la vitesse. Un objet individuel peut atteindre jusqu'à 5 To (5 497 558 138 880 octets).

3.1 Téléchargement multipart pour les fichiers importants

La limite de téléchargement de requête unique est de 4,65 Go (propriété de l'utilisateur) ou 5 Go (propriété du contrat). Au-delà de cela, vous devez utiliser le téléchargement multipart API. Les hauts niveaux boto3 et upload_file et upload_fileobj gèrent automatiquement le multipart une fois qu'un fichier dépasse le seuil configuré, ce qui est le chemin de production de niveau.

from boto3.s3.transfer import TransferConfig

# Switch to multipart above 100 MB, 8 MB parts, up to 4 parallel uploads
transfer_cfg = TransferConfig(
    multipart_threshold=100 * 1024 * 1024,
    multipart_chunksize=8 * 1024 * 1024,
    max_concurrency=4,
)

s3.upload_file(
    Filename="/tmp/build-artifact.zip",
    Bucket=bucket,
    Key="task-42/build-artifact.zip",
    Config=transfer_cfg,
    ExtraArgs={"ContentType": "application/zip"},
)

Le téléchargement multipart divise un grand objet en parties plus petites et les télécharge en parallèle, maximisant le débit. Il est disponible via le API et les SDK, mais pas via l'interface Web DCD. Si un téléchargement multipart est abandonné, les parties téléchargées restent et accumulent des coûts de stockage jusqu'à ce que vous les nettoyez, ce qui est exactement ce que la règle de cycle de vie de la section 4 gère.

3.2 Téléchargements de diffusion et Content-Type

Pour les téléchargements, diffusez le corps plutôt que de charger l'objet entier en mémoire. Le corps de la réponse est un flux de type fichier que vous pouvez itérer par morceaux.

resp = s3.get_object(Bucket=bucket, Key="task-42/report.pdf")
content_type = resp["ContentType"]  # set at upload time

with open("/tmp/report.pdf", "wb") as f:
    for chunk in resp["Body"].iter_chunks(chunk_size=1024 * 1024):
        f.write(chunk)

Définissez ContentType explicitement lors du téléchargement. Si vous le sautez, les téléchargements par défaut ont un type binaire générique et les navigateurs proposeront une invite de téléchargement au lieu d'afficher le fichier en ligne.

4. Règles de cycle de vie et contrôle des coûts

Object Storage facture ce que vous stockez, donc les objets orphelins et les téléchargements multipart en attente sont une fuite de coûts lente. Les règles de cycle de vie vous permettent d'expirer les objets automatiquement et de nettoyer les téléchargements incomplets. Vous les configurez via le S3 API.

Une configuration de cycle de vie prend en charge ces actions : expiration des versions actuelles, suppression définitive des versions non actuelles, suppression des marqueurs d'objet expirés, et suppression des téléchargements multipart incomplets. Vous pouvez configurer jusqu'à 1000 règles dans une configuration. Chaque règle s'applique à un préfixe d'objet différent, et vous ne pouvez pas configurer plus d'une règle pour le même préfixe.

4.1 Expiration des objets et nettoyage des téléchargements multipart

Cette configuration expire les téléchargements temporaires après 7 jours et annule les téléchargements multipart incomplets après 1 jour :

s3.put_bucket_lifecycle_configuration(
    Bucket=bucket,
    LifecycleConfiguration={
        "Rules": [
            {
                "ID": "expire-temp-uploads",
                "Filter": {"Prefix": "tmp/"},
                "Status": "Enabled",
                "Expiration": {"Days": 7},
            },
            {
                "ID": "abort-incomplete-multipart",
                "Filter": {"Prefix": ""},
                "Status": "Enabled",
                "AbortIncompleteMultipartUpload": {"DaysAfterInitiation": 1},
            },
        ]
    },
)

Object Storage prend actuellement en charge uniquement la classe de stockage STANDARD, vous ne pouvez donc pas utiliser les règles de cycle de vie pour transiter les objets vers un niveau plus froid. Les seules actions disponibles sont l'expiration et le nettoyage. Si un seau utilise Object Lock, les versions non actuelles ne peuvent pas être supprimées avant la fin de leur période de rétention.

5. S3 Compatibilité : ce qui est pris en charge et ce qui ne l'est pas

Object Storage a l'un des niveaux de prise en charge les plus élevés de S3 API, mais il n'est pas à 100 % équivalent à AWS. Vérifiez une fonctionnalité avant de vous appuyer sur elle, plutôt que de supposer qu'elle se comporte exactement comme AWS S3. Le tableau suivant résume les principales fonctionnalités prises en charge :

Quelques contraintes à coder. La copie d'objet ne prend pas en charge les copies inter-régionales, donc une opération de "déplacement de bucket vers une autre région" est un téléchargement-suivi-d'un-téléversement, et non une copie serveur. Le verrouillage d'objet (modes GOVERNANCE et COMPLIANCE) ne peut être activé qu'au moment de la création du bucket, et non rétroactivement sur un bucket existant. La stratégie de bucket utilise la JSON standard avec un Version de 2012-10-17. Le chiffrement en transit est TLS 1.2 ou 1.3.

5.1 CORS pour les téléversements du navigateur

Puisque les téléversements du navigateur de TaskBoard se font directement sur Object Storage via des URL pré-signées, le bucket a besoin d'une configuration CORS qui permet PUT à partir de votre origine web. Sans cela, le navigateur bloque la demande d'origine croisée avant qu'elle n'atteigne Object Storage.

s3.put_bucket_cors(
    Bucket=bucket,
    CORSConfiguration={
        "CORSRules": [
            {
                "AllowedOrigins": ["https://app.taskboard.example"],
                "AllowedMethods": ["PUT", "GET"],
                "AllowedHeaders": ["*"],
                "MaxAgeSeconds": 3000,
            }
        ]
    },
)

La référence autorisée S3 API se trouve à https://api.ionos.com/docs/s3/v2/, et la gestion des clés/buckets API est documentée à https://api.ionos.com/docs/s3-management/v1/. Lorsque vous avez des doutes sur une fonctionnalité, vérifiez-les avant d'écrire du code qui en dépend.

API Référence Quick Card

Opérations clés S3 pour Object Storage (via boto3 ou signed HTTP) :

Point de terminaison : https://s3.<region>.ionoscloud.com (par exemple s3.eu-central-1.ionoscloud.com) Authentification : Signature AWS v4 avec Clé d'accès + Clé secrète (ET NON un jeton porteur)

Laboratoire de code

Objectif : Télécharger et récupérer une pièce jointe TaskBoard via boto3 en utilisant des URL pré-signées et un téléchargement multipart, en confirmant l'authentification par clé d'accès + clé secrète.

Prérequis :

• Compte IONOS Cloud avec une clé d'accès Object Storage + clé secrète générée
• Python 3.9+ avec un boto3 compatible installé (pip install "boto3<=1.35.99") ; boto3 1.36.0 et les versions ultérieures échouent à chaque appel PutObject contre IONOS Object Storage avec InvalidTrailer, car IONOS ne prend pas en charge l'extension de somme de contrôle trailing d'AWS introduite dans cette version, donc fixez la version ou définissez AWS_REQUEST_CHECKSUM_CALCULATION=when_required et AWS_RESPONSE_CHECKSUM_VALIDATION=when_required si vous devez utiliser une version plus récente de boto3
• Un point de terminaison de région choisi (ce laboratoire utilise Francfort de / eu-central-1)

Étape 1 : Exporter les informations d'identification

export OBJSTORAGE_ENDPOINT="https://s3.eu-central-1.ionoscloud.com"
export OBJSTORAGE_ACCESS_KEY="<your-92-char-access-key>"
export OBJSTORAGE_SECRET_KEY="<your-64-char-secret-key>"
export OBJSTORAGE_REGION="eu-central-1"

Sortie attendue :

(no output; variables set)

Étape 2 : Créer le client et un seau

import os, boto3
from botocore.config import Config

s3 = boto3.client("s3",
    endpoint_url=os.environ["OBJSTORAGE_ENDPOINT"],
    aws_access_key_id=os.environ["OBJSTORAGE_ACCESS_KEY"],
    aws_secret_access_key=os.environ["OBJSTORAGE_SECRET_KEY"],
    region_name=os.environ["OBJSTORAGE_REGION"],
    config=Config(signature_version="s3v4"))

bucket = "taskboard-lab-<your-initials>"
s3.create_bucket(Bucket=bucket)
print("created", bucket)

Le texte à traduire est vide, veuillez fournir le texte à traduire.

created taskboard-lab-ct

Étape 3 : Générer une URL de téléchargement pré-signée

url = s3.generate_presigned_url("put_object",
    Params={"Bucket": bucket, "Key": "task-1/note.txt", "ContentType": "text/plain"},
    ExpiresIn=900)
print(url)

Sortie attendue :

https://s3.eu-central-1.ionoscloud.com/taskboard-lab-ct/task-1/note.txt?X-Amz-Algorithm=...

Étape 4 : Télécharger via l'URL pré-signée avec curl

echo "hello taskboard" > note.txt
curl -X PUT -H "Content-Type: text/plain" --upload-file note.txt "<PASTE_PRESIGNED_URL>"

Sortie attendue :

(HTTP 200, empty body)

Étape 5 : Téléchargement multipart de un grand fichier

Pour télécharger un grand fichier, vous pouvez utiliser la fonctionnalité de téléchargement multipart. Cette fonctionnalité vous permet de télécharger un fichier en plusieurs parties, ce qui peut être utile pour les fichiers très volumineux.

from boto3.s3.transfer import TransferConfig
cfg = TransferConfig(multipart_threshold=5*1024*1024, multipart_chunksize=5*1024*1024)
s3.upload_file("bigfile.bin", bucket, "task-1/bigfile.bin", Config=cfg,
               ExtraArgs={"ContentType": "application/octet-stream"})
print("uploaded large file")

Le texte à traduire est vide, veuillez fournir le texte technique à traduire.

uploaded large file

Étape 6 : Téléchargement via une URL GET pré-signée

get_url = s3.generate_presigned_url("get_object",
    Params={"Bucket": bucket, "Key": "task-1/note.txt"}, ExpiresIn=300)
import urllib.request
print(urllib.request.urlopen(get_url).read().decode())

Sortie attendue :

hello taskboard

Étape 7 : Ajouter une règle de cycle de vie pour nettoyer les téléchargements incomplets

s3.put_bucket_lifecycle_configuration(Bucket=bucket,
    LifecycleConfiguration={"Rules": [{
        "ID": "abort-mpu", "Filter": {"Prefix": ""}, "Status": "Enabled",
        "AbortIncompleteMultipartUpload": {"DaysAfterInitiation": 1}}]})
print("lifecycle set")

Le texte à traduire est vide, veuillez fournir le texte à traduire.

lifecycle set

Liste de validation :

• [ ] Bucket créé et visible dans s3.list_buckets()
• [ ] Fichier téléchargé et téléchargé via des URL pré-signées
• [ ] Téléchargement multipart de un grand fichier a réussi
• [ ] Règle de cycle de vie appliquée sans erreur

Nettoyage :

for obj in s3.list_objects_v2(Bucket=bucket).get("Contents", []):
    s3.delete_object(Bucket=bucket, Key=obj["Key"])
s3.delete_bucket(Bucket=bucket)
print("cleaned up")

Erreurs courantes

Erreurs de développement à éviter avec l'intégration de Object Storage :

1. Essayer d'authentifier avec votre jeton d'accès Cloud API

   • Problème : Chaque requête S3 renvoie 403 SignatureDoesNotMatch ou InvalidAccessKeyId.
   • Pourquoi cela se produit-il : Object Storage utilise la signature AWS avec une paire de clé d'accès + clé secrète, et non le jeton d'accès IONOS Cloud utilisé par le REST du API et non les rôles IAM. Ce sont des systèmes de crédentials entièrement séparés.
   • Correction : Générez une clé Object Storage dédiée (DCD ou Management API) et passez-la en tant que aws_access_key_id / aws_secret_access_key. Les clés actuelles sont de 92 et 64 caractères ; rejetez les anciennes suppositions de 20/40 caractères.

2. Omission de l'endpoint_url et utilisation d'AWS à la place

   • Problème : Les requêtes expirent, échouent DNS, ou atterrissent sur des ressources AWS réelles S3.
   • Pourquoi cela se produit-il : boto3 est défini par défaut sur les points de terminaison AWS. Sans endpoint_url, le SDK ne communique jamais avec IONOS.
   • Correction : Transmettez toujours le point de terminaison spécifique à la région, par exemple endpoint_url="https://s3.eu-central-1.ionoscloud.com", et assurez-vous que region_name correspond à la région de ce point de terminaison.

3. Incompatibilité de type de contenu qui brise les téléchargements pré-signés

   • Problème : Le navigateur PUT vers une URL pré-signée renvoie 403 SignatureDoesNotMatch.
   • Pourquoi cela se produit-il : L'en-tête Content-Type a été inclus lors de la signature de l'URL, mais le client a envoyé un en-tête Content-Type différent (ou aucun). Les en-têtes signés doivent correspondre exactement.
   • Correction : Signez avec le type de contenu exact et envoyez l'en-tête identique à partir du client, ou ommez ContentType de Params entièrement afin qu'il ne fasse pas partie de la signature.

Résumé

Vous pouvez maintenant intégrer IONOS Cloud Object Storage dans le code d'application via son S3-compatible API. Vous configurez un client boto3 avec le point de terminaison régional correct et l'authentification Access Key + Secret Key, déplacez les octets de fichiers de votre chemin API avec des URL de téléchargement et de téléchargement pré-signées, gérez les fichiers volumineux avec un téléchargement multipartite, diffusez les téléchargements et appliquez des règles de cycle de vie pour maintenir le coût de stockage sous contrôle. Le flux d'attachement TaskBoard permet maintenant aux navigateurs de télécharger directement sur Object Storage tandis que le API n'enregistre que les métadonnées.

Points clés :

• Object Storage s'authentifie avec une clé d'accès de 92 caractères et une clé secrète de 64 caractères via AWS Signature v4, et non avec le jeton porteur Cloud API ou les rôles IAM
• Vous devez toujours passer un endpoint_url explicite correspondant à la région du bucket ; les noms de bucket sont uniques au niveau mondial et comportent 3 à 63 caractères
• Les URL pré-signées accordent un accès limité dans le temps, sans informations d'identification, de sorte que les clients puissent télécharger et télécharger directement contre Object Storage
• Utilisez le téléchargement multipartite pour les fichiers supérieurs à la limite de requête unique (4,65 Go pour les utilisateurs, 5 Go pour les contrats) ; les objets peuvent atteindre 5 To
• Object Storage a une compatibilité élevée avec S3, mais pas une parité totale : la copie inter-région n'est pas prise en charge, Object Lock est uniquement disponible au moment de la création, et seule la classe de stockage STANDARD existe

Terminologie importante :

• Clé d'accès / Clé secrète : La paire d'informations d'identification S3 (92 et 64 caractères) qui authentifie chaque requête Object Storage via AWS Signature.
• URL pré-signée : Une URL signée et limitée dans le temps qui accorde l'accès à un objet unique sans partager de clés ou modifier les autorisations ; le fondement des téléchargements et des téléchargements directs de navigateur.
• Téléchargement multipartite : La division d'un objet volumineux en parties téléchargées en parallèle ; obligatoire au-delà de la limite de taille de requête unique et nettoyée via des règles de cycle de vie.
• Règle de cycle de vie : Une configuration de bucket (jusqu'à 1000 règles) qui expire les objets et annule les téléchargements multipartites incomplets de manière automatique.
• Type de bucket : Les buckets appartenant à l'utilisateur par rapport aux buckets appartenant au contrat, qui diffèrent en termes de disponibilité de la région, de limites de bucket par utilisateur et de plafonds de téléchargement unique.

Prochaines étapes

Continuer l'apprentissage : Unité 4.3 : Intégration de diffusion d'événements

Sujets connexes :

• Unité 2.4 : Provisionnement de stockage en tant que code
• Unité 4.1 : Intégration de base de données et de mise en cache