Remarque :

Flux de messages AVRO à l'aide d'Oracle Cloud Infrastructure Streaming et d'OCI Data Flow grâce au traitement par micro-batch

Introduction

Dans le paysage actuel axé sur les données, la capacité de traiter et d'analyser des flux de données en temps réel est cruciale pour les entreprises qui cherchent à obtenir des informations et à réagir rapidement à l'évolution des conditions. Les technologies de traitement des données de diffusion en continu sont devenues des solutions puissantes pour la gestion de flux de données continus volumineux. Dans ce tutoriel, nous allons étudier une approche novatrice pour diffuser efficacement les messages AVRO à l'aide d'Oracle Cloud Infrastructure (OCI) Streaming, associée à la technique de traitement par micro-batch, et améliorée avec les fonctionnalités sans serveur d'Oracle Functions basées sur le projet FN open source.

Introduction à AVRO et à la diffusion en continu de données

AVRO, un format de sérialisation des données largement adopté, est connu pour son efficacité dans la représentation de structures de données complexes et sa compatibilité avec divers langages de programmation. Lorsqu'elle est intégrée aux technologies de diffusion en continu, AVRO permet aux entreprises de transmettre et de traiter des données quasiment en temps réel, ce qui leur permet d'extraire des informations précieuses sans la latence généralement associée au traitement par lots.

OCI Streaming : transmission de données en temps réel

Oracle Cloud Infrastructure (OCI) dispose d'un large éventail d'outils pour la gestion des données dans le cloud, OCI Streaming étant un service de ce type adapté aux flux de données à haut débit en temps réel. Grâce à OCI Streaming, les développeurs peuvent créer des pipelines de données évolutifs et fiables qui assimilent, traitent et distribuent efficacement des flux de données.

Spark géré par OCI Data Flow : une solution sans verrouillage

Oracle Cloud Infrastructure (OCI) Data Flow est un service Apache Spark entièrement géré qui effectue des tâches de traitement sur des ensembles de données extrêmement volumineux sans infrastructure à déployer ou à gérer.

Traitement par micro-batch Le traitement par micro-batch consiste à décomposer les flux de données entrants en lots compacts en utilisant le temps ou la taille comme critère. Ces lots sont ensuite traités en tant que petits travaux. Contrairement à la gestion constante et individuelle des enregistrements dans le traitement de flux, le traitement par micro-batch introduit un peu de retard et de stockage avant le traitement, ce qui permet de mieux contrôler ce qu'il faut faire avec les données. Contrairement au traitement par lots traditionnel qui traite les ensembles de Big Data à intervalles réguliers, le traitement par micro-batch fournit un traitement et une livraison quasiment en temps réel des résultats.

Débloquer la synergie : OCI Streaming, OCI Data Flow et Oracle Functions

Ce tutoriel aborde la fusion d'OCI Streaming, d'OCI Data Flow a géré Spark Streaming et d'Oracle Functions. Nous vous guiderons tout au long du processus de configuration d'un pipeline de données de diffusion en continu de bout en bout qui ingère des messages encodés AVRO, les traite efficacement à l'aide des fonctionnalités de traitement par micro-batch Spark gérées par OCI Data Flow et introduit un traitement sans serveur basé sur des événements avec Oracle Functions.

Objectif

Utilisez le traitement micro-batch Spark géré par OCI Streaming et OCI Data Flow pour créer un pipeline de traitement de données efficace et en temps réel au format AVRO.

IMPORTANT : Ce tutoriel est conçu uniquement à des fins d'enseignement et d'étude. Il fournit un environnement permettant aux apprenants d'expérimenter et d'acquérir une expérience pratique dans un cadre contrôlé. Il est essentiel de noter que les configurations et pratiques de sécurité utilisées dans cet exercice pourraient ne pas convenir à des scénarios réels.

Les considérations de sécurité pour les applications du monde réel sont souvent beaucoup plus complexes et dynamiques. Par conséquent, avant de mettre en œuvre l'une des techniques ou configurations présentées ici dans un environnement de production, il est essentiel de procéder à une évaluation et à un examen complets de la sécurité. Cet examen devrait porter sur tous les aspects de la sécurité, y compris le contrôle d'accès, le cryptage, la surveillance et la conformité, afin de garantir que le système s'aligne sur les stratégies et normes de sécurité de l'organisation.

La sécurité doit toujours être une priorité absolue lors du passage d'un environnement de laboratoire à un déploiement réel.

Flux de processus
T0_1

Architecture globale
T0_1

Prérequis - Oracle Cloud Infrastructure

Prérequis - Environnement machine local

Tâche 1 : Configurer des groupes dynamiques

  1. Accédez à votre domaine, cliquez sur Groupes dynamiques et créez les groupes suivants.

    Nom de groupe : MyFunctions

    ALL {resource.type = 'fnfunc', resource.compartment.id = 'pasteYourCompartmentID'}

    Nom de groupe : ContainerIntances

    ALL {resource.type='compute-container-instances',  resource.compartment.id = 'pasteYourCompartmentID'}

    Nom de groupe : DataFlowDynamicGroup

    ALL {resource.type='dataflowrun', resource.compartment.id = 'pasteYourCompartmentID'}

Tâche 2 : créer des stratégies

Tâche 3 : création de buckets de stockage et téléchargement du schéma AVRO

  1. Accédez à Buckets, cliquez sur Créer un bucket et créez un bucket nommé avro-schema-bucket pour stocker le fichier de schéma AVRO.

    T3_1

  2. Sélectionnez à présent votre bucket et PRENEZ NOTE de l'espace de noms, nous en aurons besoin ultérieurement.

    T3_1

  3. Téléchargez le fichier user.asvc vers ce bucket créé.

    T3_1

Tâche 4 : création de la rubrique de transmission en continu OCI privée

  1. Accédez à Analytics et IA, puis cliquez sur Streaming et créez un flux nommé FrontDoorTopic.

    T4_0

  2. Sélectionnez Pools de flux de données, cliquez sur PrivatePool, puis sur l'option Paramètres de connexion Kafka et sur TKE NOTE des champs. Nous en aurons besoin ultérieurement.

    T4_0

Tâche 5 : création d'AUTH TOKEN

Créez AUTH TOKEN pour votre utilisateur. Cette opération est requise pour utiliser la rubrique Kafka

  1. Cliquez sur l'icône en haut à droite de l'utilisateur, puis sélectionnez l'option Paramètres d'utilisateur.

  2. Cliquez sur Jetons d'authentification, puis générez un nouveau jeton et TAKE NOTE de votre jeton.

    T4_1

Tâche 6 : création d'un registre de conteneurs

  1. Accédez au menu Services de développeur, cliquez sur Registre de conteneurs et créez les référentiels privés suivants.

    Nom de référentiel Type
    api-avro-sample_a Privé
    api-avro-sample_b Privé
    fn-recep-avro Privé

  2. Vérifiez les référentiels et TAKE NOTE de l'espace de noms.

    T6_1

  3. Ouvrez le shell de terminal sur lequel l'interface de ligne de commande et Docker OCI sont installées, puis connectez-vous au registre. Vérifiez l'URL correcte de votre région. Dans ce tutoriel, nous utilisons Est du Brésil (Sao Paulo) où l'URL de registre est gru.ocir.io.

    docker login gru.ocir.io
Username: <your container namespace>/youruser
Password: YOUR_AUTH_TOKEN_CREATED_EARLIER

    T6_1

Tâche 7 : création d'OCI Vault

Créez OCI Vault et fournissez les variables nécessaires qui seront utilisées ultérieurement dans ce tutoriel.

  1. Accédez à Identifier et sécurité, cliquez sur Coffre, puis sur Créer un coffre.

    T7_1new

  2. Sélectionnez le nouveau coffre et créez-en des clés de cryptage maître.

    T7_1new

  3. Créez une clé secrète nommée AUTH_KEY et collez la clé d'authentification que vous avez créée précédemment.

    T7_1new

  4. Répétez le processus de création de clé secrète et créez les clés secrètes suivantes :

    Nom variable Valeur
    KAFKA_BOOTSTRAPSERVER "Le serveur boostrap de votre configuration OCI Streaming"
    KAFKA_TOPIC “FrontDoorTopic”
    KAFKA_USERNAME "Votre nom utilisateur + votre ID streampool à partir de votre configuration OCI Streaming"
    AUTH_KEY "Votre jeton AUTH que vous avez créé lors des étapes précédentes"

  5. Notez l'OCID de clé secrète créé pour chaque clé secrète et créez un fichier de configuration.

    • Le fichier config.properties contient les variables de mise en correspondance entre l'application et les instances de clé secrète du coffre. L'application utilisera ce fichier pour identifier les clés secrètes de coffre à collecter lors de l'exécution.

    • Créez un fichier sur l'ordinateur local sur lequel vous avez accès à l'interface de ligne de commande OCI :
      Remplacez l'OCID de chaque sécurité
      Nom de fichier : config.properties

      kafka_bootstrapserver_vaultOCID=ocid1.vaultsecret.REPLACE-WITH-YOURS
kafka_topic_vaultOCID=ocid1.vaultsecret.REPLACE-WITH-YOURSxxxxxx
kafka_username_vaultOCID=ocid1.vaultsecret.REPLACE-WITH-YOURS
auth_token_vaultOCID=ocid1.vaultsecret.oc1.REPLACE-WITH-YOURS

  6. Accédez à Buckets, cliquez sur Créer un bucket et créez un bucket nommé config pour stocker le fichier config.properties.

  7. Téléchargez le fichier config.properties vers le bucket de stockage config.

    ls -lrt config.properties
oci os object put -bn config --file config.properties --force

    T7_1new

Tâche 8 : créez un message AVRO simple et enregistrez-le dans un fichier à l'aide de l'exemple de code python fourni

  1. Ouvrez le terminal shell sur lequel l'interface de ligne de commande OCI, Docker et Python3 sont installés et créez un fichier AVRO contenant un message unique basé sur le même schéma AVRO que celui que nous avons téléchargé précédemment dans le stockage d'objets.

    Remarque : vous devez vérifier la version de Python, nous utilisons Python 3.9.16 dans ce tutoriel, les versions antérieures risquent de ne pas fonctionner.

  2. Obtenez le code à partir d'ici Create_avro_sample.zip.

  3. Décompressez-l'à l'emplacement de votre choix, puis exécutez le programme pour générer un exemple de message AVRO :

    cd ~
mkdir create_avro_sample
cd create_avro_sample
unzip CreateAVRO_SampleFile.zip
# Check the files are there
ls -lrt
# install the python dependencies on requirements.txt
pip3 install -r requirements.txt
# Run the program and create an AVRO message file
python3 create_avro_sample.py meu_file.bin '{"id":10029,"name":"John","email":"john@bla.com"}'

    T8_1 T8_1 T8_1

Tâche 9 : création de la fonction OCI pour recevoir le message AVRO et publication dans la rubrique OCI Streaming

  1. Accédez à Services de développeur, sous Functions, cliquez sur Applications, puis sur Créer une application.

    T9_1

  2. Accédez à votre shell de terminal sur lequel vous avez installé Docker, l'interface de ligne de commande OCI, l'interface de ligne de commande FN et exécutez les commandes suivantes pour initialiser la fonction.

    Remarque : si vous avez suivi les étapes, votre commande de connexion Docker a déjà été exécutée pour le moment. Sinon, passez à l'étape de connexion Docker sur la tâche Créer un registre de conteneurs.

    fn create context oci-cloud --provider oracle
fn use context oci-cloud
fn update context oracle.compartment-id PASTE_YOUR_COMPARTMENT_OCID
fn update context api-url https://functions.sa-saopaulo-1.oraclecloud.com
fn update context registry gru.ocir.io/PASTE_YOUR_REGISTRY_NAMESPACE

    Remarque : dans ce tutoriel, nous utilisons la région Est du Brésil (Sao Paulo). Si vous utilisez une autre région, vous devez modifier les emplacements api-url et registre.

    T9_1

  3. Créez une fonction Hello-world simple pour vous assurer que tous vos paramètres sont corrects.

    fn init --runtime python fn-recep-avro
cd fn-recep-avro
fn deploy --app MyReceptionApp
fn invoke MyReceptionApp fn-recep-avro

    T9_1

  4. Obtenez l'exemple de code de la fonction AVRO dans le fichier fn-recep-avro.zip et remplacez le code hello-world créé précédemment. Vous devez obtenir les fichiers func.py et requirements.txt pour pouvoir travailler.

    # Check you have the right code for func.py & requirements.txt (you got from zip file)
ls -lrt

    T9_1

  5. Créer le nouveau code et déployer la fonction

    fn deploy --app MyReceptionApp

    T9_1

  6. Pour appeler la fonction, nous devons transmettre un message AVRO en tant que paramètre. Pour cela, nous allons utiliser l'exemple de fichier de messages AVRO créé à partir des étapes précédentes. La première fois qu'une fonction est appelée, elle prend un peu plus de temps car elle doit être démarrée.

    # Check where you created the sample avro message file
ls -lrt ../create_avro_sample/

# Invoke the function to check if it's working as expected
echo -n -e "$(cat ../create_avro_sample/meu_file.bin)" | fn invoke MyReceptionApp fn-recep-avro

    T9_1

Tâche 10 : création d'une passerelle d'API pour exposer la fonction

  1. Dans votre console, cliquez sur Services de développeur, puis, sous Gestion des API, cliquez sur Passerelles, puis sur Créer une passerelle.

    T10_1

  2. Une fois créées, cliquez sur l'option Déploiements, puis sur Créer un déploiement.

    Nom : RecepFunction
    Préfixe de chemin : /

    • Dans Authentification, choisissez Aucune authentification car il s'agit d'un exercice simple et aucune authentification d'API n'est implémentée. L'objectif principal ici est de démontrer un appel HTTPS passant par un message AVRO binaire via API, et dans le cadre de cet exercice, nous n'implémenterons aucune méthode d'authentification pour ce laboratoire simple.
    • Avant de passer à un environnement réel, veillez à suivre les meilleures pratiques de sécurité pour API Gateway.
    • Pour plus de détails, reportez-vous à Sécurisation des passerelles et des ressources d'API.

    Routage 1 : Chemin : /

    Méthos : POST
    Type de back-end : fonctions Oracle
    Application : sélectionnez votre fonction

    T9_1

    T9_1

    T9_1

    T9_1

  3. Vérifiez l'adresse de passerelle d'API et prenez note.

    T9_1

  4. Ouvrez le terminal shell Linux et appelez API Gateway. Remplacez l'URL d'API par l'adresse correcte obtenue à l'étape précédente.

    cd create_avro_sample/
ls -lrt
curl -X POST -H "Content-Type: application/octet-stream" \
     -d "$(echo -n -e "$(cat meu_file.bin)")" \
     https://xxxxxxxxxxxxx.apigateway.sa-saopaulo-1.oci.customer-oci.com/

    T9_1

Point de reprise

T9_1

Tâche 11 : création d'une image de conteneur pour le type d'API A

Remarque : les API de type A et B sont fondamentalement identiques avec un message d'en-tête différent pour simuler deux API différentes.

  1. Obtenez le code de l'API type A et décompressez-le dans votre terminal shell Linux api-avro-sample_a.zip.

  2. Obtenez l'espace de noms du registre de conteneurs obtenu lors des étapes précédentes et créez l'emplacement du registre d'applications, en suivant le modèle ci-dessous. L'URL d'ocir est basée sur votre région, c'est-à-dire gru.ocir.io pour Brasil East(SaoPaulo)

    [ocir url]/[votre espace de noms]/api-avro-sample_a:latest

  3. Dans votre terminal shell Linux, créez et propagez l'image docker pour cette API.

    ls -lrt
docker build . -t gru.ocir.io/yournamespace/api-avro-sample_a:latest
docker push gru.ocir.io/yournamespace/api-avro-sample_a:latest

    T10_1 T10_1

Tâche 12 : création d'une image de conteneur pour le type d'API B

  1. Obtenez le code de l'API type B et décompressez-le dans votre terminal shell Linux api-avro-sample_b.zip.

  2. Obtenez l'espace de noms du registre de conteneurs obtenu lors des étapes précédentes et créez l'emplacement du registre d'applications, en suivant le modèle ci-dessous. L'URL d'ocir est basée sur votre région, c'est-à-dire gru.ocir.io pour Brasil East(SaoPaulo)

    [ocir url]/[votre espace de noms]/api-avro-sample_b:latest

  3. Dans votre terminal shell Linux, créez et propagez l'image docker pour cette API.

    ls -lrt
docker build . -t gru.ocir.io/yournamespace/api-avro-sample_b:latest
docker push gru.ocir.io/yournamespace/api-avro-sample_b:latest

    T10_1

    T10_1

  4. Vérifiez sur votre page de registre de conteneurs si l'image a été propagée avec succès.

    T10_1

Tâche 13 : déploiement des API dans le service de conteneur

  1. Accédez à Services de développeur, Instances de conteneur et cliquez sur Créer une instance de conteneur.

    T13_1

    T13_1

  2. Répétez l'étape 1 pour api-type-b et sélectionnez l'image correcte pour l'API TYPE B.

    1. Accédez à Services de développeur, Instances de conteneur, cliquez sur Créer une instance de conteneur et répétez les étapes de déploiement du type d'API B.

    2. Obtenez l'adresse de nom de domaine qualifié complet interne à partir de vos instances de conteneur.

      T14_1

      • Cliquez sur l'instance de conteneur et notez chaque adresse de nom de domaine qualifié complet interne.

      T14_1

    3. Accédez à Identifier et fixer le secret, cliquez sur Coffre, sélectionnez votre VAULT et créez deux secrets.

      Nom secret Valeur
      API_TYPE_A_URL coller l'adresse privée de nom de domaine qualifié complet interne pour l'API de type A
      API_TYPE_B_URL coller l'adresse privée de nom de domaine qualifié complet interne pour le type d'API B

      Prenez note de chaque OCID de clé secrète

      Votre coffre doit se présenter comme suit :

      T14_1

    4. Modifiez le fichier config.properties que vous avez téléchargé vers le bucket de stockage config et ajoutez de nouvelles entrées pour l'OCID de clé secrète.

      ls -lrt config.properties
vi config.properties
api_type_a_url_vaultOCID=paste_API_TYPE_A_URL_secretOCID
api_type_b_url_vaultOCID=paste_API_TYPE_B_URL_secretOCID

# After save, please upload the new version to Object Storage
cat config.properties
oci os object put -bn config --file config.properties --force

      Votre fichier se présente comme suit :
      T14_1

      T14_1

Tâche 14 : test des API à l'aide de create_avro_sample.py

  1. Accédez à votre terminal shell Linux où vous avez enregistré le fichier create_avro_sample.py à partir de la tâche 7 et créez des messages pour tester les appels d'API. Nous créons deux nouveaux fichiers AVRO avec des ID différents (1010 et 1020) que nous utiliserons comme filtre dans le programme Spark Stream (DataFlow).

    ls -lrt
python3 create_avro_sample.py type_a_message.bin '{"id":1010,"name":"Paul that goes to API type A","email":"paul@bla.com"}'

python3 create_avro_sample.py type_b_message.bin '{"id":1020,"name":"Mary that goes to API type B","email":"mary@bla.com"}'

    T14_1

  2. Appeler les API transmettant le message AVRO à tester fonctionne correctement. Accédez à votre page Instances de conteneur et obtenez l'adresse de nom de domaine qualifié complet interne pour chacune des API api-type-a et api-type-b. N'oubliez pas de remplacer l'URL ci-dessous pour l'adresse de nom de domaine qualifié complet interne correspondante à partir de vos API.

    ls -lrt type*

curl -i -X POST -H "Content-Type: application/octet-stream" \
   --data-binary "@type_a_message.bin" \
   xxx.xx.x.xxx

curl -i -X POST -H "Content-Type: application/octet-stream" \
   --data-binary "@type_b_message.bin" \
   xxx.xxx.xx.xxx

    T14_1

Tâche 15 : configuration de l'application de transmission en continu Java Spark

  1. Accédez à Buckets, cliquez sur Créer un bucket et créez deux buckets appelés dataflow-app-avro et dataflow-logs-avro. Cette opération sera utilisée pour télécharger l'application java.

  2. Vérifiez deux fois les versions de votre environnement java.

    Java

    java 11.0.8 2020-07-14 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.8+10-LTS)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.8+10-LTS, mixed mode)

    Maven

    Apache Maven 3.5.4 (Red Hat 3.5.4-5)
Maven home: /usr/share/maven
Java version: 11.0.20, vendor: Red Hat, Inc., runtime: /usr/lib/jvm/java-11-openjdk-11.0.20.0.8-3.0.1.el8.x86_64
Default locale: en_US, platform encoding: ANSI_X3.4-1968
OS name: "linux", version: "5.15.0-103.114.4.el8uek.x86_64", arch: "amd64", family: "unix"

  3. Téléchargez l'exemple de code et décompressez-le sur votre environnement local comportant oci-cli, docker, java et maven : spark-consume-avro-message.zip.

    unzip spark-consume-avro-message.zip
cd spark-consume-avro-message
ls -lrt

    T15_1 T15_1

    Un petit aperçu du code proxy pour appeler les types d'instance de conteneur A et B.

    Vérifiez le fichier de programme principal .src/main/java/example/Example.java.... T15_1

  4. Etant donné que ce programme Java utilise une bibliothèque pour gérer spark-avro, nous devons packager la dépendance pour la transmettre au flux de données. Pour cela, nous allons utiliser Data Flow Dependency Packager. Si vous avez besoin de plus de détails, vous pouvez accéder à Data Flow Dependency Packager.

    Le package org.apache.spark:spark-avro_2.12 :3.2.1 est déjà déclaré dans le fichier packages.txt. Vous devez simplement le packager en exécutant :

    docker run --privileged --platform linux/amd64 --rm -v $(pwd):/opt/dataflow  --pull always -it phx.ocir.io/oracle/dataflow/dependency-packager:latest -p 3.8

    T15_1 T15_1 T15_1

  5. Téléchargez le fichier archive.zip dans le bucket de stockage appelé dataflow-app-avro à l'aide d'oci-cli.

    oci os object put -bn dataflow-app-avro --file archive.zip --force

  6. Compilez, packagez l'application java et téléchargez-la vers le bucket de stockage dataflow-app-avro.

    ls -lrt
mvn clean install

    T15_1
    ...réduction du nombre de lignes du journal de compilation... T15_1

    # upload the JAR file to the storage bucket
oci os object put -bn dataflow-app-avro --file target/consumekafka-1.0-SNAPSHOT.jar --force

    T15_1

  7. Vérifiez votre bucket de stockage dataflow-app-avro actuel et assurez-vous qu'il ressemble à ceci.

    T15_1

  8. Accédez à Analytics et IA, puis sous Data Lake, cliquez sur Data Flow, sélectionnez le menu de gauche Adresses privées et cliquez sur Créer une adresse privée.

    • L'adresse privée est nécessaire car nous utilisons le sous-réseau PRIVATE pour les instances de conteneur et le pool OCI Streaming.

    • Veillez à remplir les zones DNS avec le nom de domaine qualifié complet interne des instances de conteneur OCI et du pool OCI Streaming avec une délimitation par des virgules.

      T15_1

  9. Accédez à Analytics et IA, puis sous Lac de données, cliquez sur Flux de données, puis sur Créer une application.

    T15_1
    T15_1
    T15_1
    T15_1
    T15_1
    T15_1

    • Une fois créé, sélectionnez le flux de données spark-lab-avro, puis cliquez sur Run pour démarrer le programme, le démarrage prend généralement jusqu'à 8 minutes.

      T15_1
      T15_1

  10. Vérifiez l'application de flux de données en cours d'exécution et ouvrez le fichier SparkUI qui affichera les travaux en cours et l'application fonctionne.

    T15_1

    T15_1

    T15_1

Tâche 16 : validation du flux

Appelez la fonction et transmettez un message pour vérifier que tout le flux fonctionne comme prévu.

  1. Ouvrez le terminal shell Linux dans lequel vous avez créé les exemples de message type_a_message.bin et type_b_message.bin, puis envoyez le message. Remplacez l'URL d'API par l'adresse correcte obtenue lors de la création de la passerelle d'API.

    cd create_avro_sample/
ls -lrt
curl -X POST -H "Content-Type: application/octet-stream" \
   -d "$(echo -n -e "$(cat type_a_message.bin)")" \
   https://xxxxxxxxxxxxx.apigateway.sa-saopaulo-1.oci.customer-oci.com/

    T16_1

  2. Vérifions si le type d'API A a été appelé en consultant les journaux sur l'instance de conteneur.

    T16_1 T16_1

Vous pouvez répéter le processus et envoyer un fichier type_b_message.bin, et il appellera l'instance de conteneur de type B.

T9_1

Remerciements

Ressources de formation supplémentaires

Explorez d'autres ateliers sur docs.oracle.com/learn ou accédez à davantage de contenu de formation gratuit sur le canal Oracle Learning YouTube. En outre, accédez à education.oracle.com/learning-explorer pour devenir un explorateur Oracle Learning.

Pour consulter la documentation produit, consultez Oracle Help Center.