Utiliser les API Datastream

Pour les entreprises disposant de nombreuses sources de données isolées, il peut être difficile d'accéder aux données de l'ensemble de l'organisation, en particulier en temps réel. Cela entraîne un accès limité et lent aux données qui nuit à la capacité d'introspection de l'organisation.

Datastream offre un accès en quasi-temps réel qui permet de modifier les données de différentes sources sur site et sources cloud afin de créer un accès aux données organisationnelles. Datastream offre une expérience de configuration simple et une API de consommation unifiée afin de démocratiser l'accès aux données les plus récentes dans l'entreprise, ce qui rend possible des intégrations en quasi-temps réel.

Une telle intégration consiste à transférer les données d'une base de données source vers une file d'attente ou un service de stockage basé sur le cloud, puis à les convertir dans un format lisible par d'autres applications et services qui communiquent avec le service de stockage ou la file d'attente.

Dans ce tutoriel, vous allez apprendre à utiliser Datastream pour transférer des schémas, des tables et des données à partir d'une base de données Oracle source vers un dossier cible situé dans un bucket Cloud Storage. Cloud Storage est un service Web permettant de stocker des données sur Google Cloud et d'y accéder. Le service associe les performances et l'évolutivité du cloud de Google à des fonctionnalités avancées de sécurité et de partage.

Dans le cadre du transfert de ces informations dans un dossier du bucket Cloud Storage de destination, Datastream traduit ces informations au format Avro. Le format Avro est défini par un schéma écrit en JSON (JavaScript Object Notation). Cette traduction vous permet de lire les données de différentes sources de manière uniforme.

Objectifs

Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes :

  • Définir des variables d'environnement. Vous utiliserez ces variables pour effectuer des requêtes sur Datastream afin de créer et de gérer des profils de connexion et un flux.
  • Créer et gérer des profils de connexion pour une base de données source et un bucket de destination dans Cloud Storage. En créant ces profils de connexion, vous générez des enregistrements contenant des informations sur la base de données source et le bucket Cloud Storage de destination. Le flux Datastream utilise les informations des profils de connexion pour transférer les données de la base de données source vers un dossier du bucket de destination.
  • Créer et gérer un flux. Datastream utilise ce flux pour transférer des données, des schémas et des tables de la base de données source vers un dossier du bucket de destination.
  • Vérifier que Datastream transfère les données et les tables associées à un schéma de la base de données Oracle source vers un dossier du bucket de destination, puis convertit ces données au format de fichier Avro.
  • Nettoyer les ressources que vous avez créées dans Datastream afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées.

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

  • Cloud Storage

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Avant de commencer

  1. Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.
  2. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  3. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  4. Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

    Accéder au sélecteur de projet

  5. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

  6. Activez l'API Datastream.

    Activer l'API

  7. Assurez-vous que le rôle "Administrateur de flux de données" est attribué à votre compte utilisateur.

    Accéder à la page IAM

  8. Assurez-vous de disposer d'une base de données source à laquelle Datastream peut accéder. Pour ce tutoriel, une base de données Oracle est utilisée comme source.
  9. Configurez votre base de données source pour autoriser les connexions entrantes provenant d'adresses IP publiques Datastream. Consultez la section Listes d'autorisation d'adresses IP et régions pour accéder aux emplacements de toutes les régions Datastream et aux adresses IP publiques associées.
  10. Assurez-vous d'avoir configuré un bucket Cloud Storage de destination auquel Datastream peut accéder en utilisant la liste d'autorisation d'adresses IP, le tunnel SSH de transfert ou la méthode de connectivité réseau d'appairage de VPC.
  11. Assurez-vous que la base de données source contient des données, des tables et des schémas que Datastream peut transférer vers un dossier du bucket Cloud Storage de destination.
  12. Téléchargez et installez Cloud Shell. Cette application cliente vous permet d'accéder à vos ressources cloud (y compris Datastream) via une ligne de commande.
  13. Installez et configurez l'utilitaire jq. Cet utilitaire est un outil de traitement JSON léger et flexible sur ligne de commande. Vous utiliserez cet outil de traitement pour afficher des commandes cURL complexes sous forme de texte facile à lire.

Définir des variables d'environnement

Dans cette procédure, vous allez définir les variables suivantes :

  • $PROJECT : cette variable est associée à votre projet Google Cloud. Toutes les ressources Google Cloud que vous allouez et utilisez doivent appartenir à un projet.
  • $TOKEN : cette variable est associée à un jeton d'accès. Le jeton d'accès fournit une session que Cloud Shell utilise pour effectuer des tâches dans Datastream par l'intermédiaire des API REST.
  1. Lancez votre application Cloud Shell.

  2. Après vous être authentifié dans votre application avec votre compte Google, saisissez gcloud auth login.

  3. Lorsque l'invite Do you want to continue (Y/n)? s'affiche, saisissez Y.

  4. Ouvrez un navigateur Web et copiez l'URL dans le navigateur.

  5. Authentifiez-vous auprès du SDK Google Cloud avec votre compte Google. Un code apparaît sur la page Connexion. Ce code est votre jeton d'accès.

  6. Copiez le jeton d'accès, collez-le dans le paramètre Enter verification code: de votre application Cloud Shell, puis appuyez sur Enter.

  7. Lorsque vous y êtes invité, saisissez PROJECT="[YOUR_PROJECT_NAME]" pour définir la variable d'environnement $PROJECT sur votre projet Google Cloud.

  8. Lorsque vous y êtes invité, saisissez gcloud config set project [YOUR_PROJECT_NAME] pour définir le projet sur lequel vous souhaitez travailler dans votre projet Google Cloud.

    Votre invite de commande est mise à jour en fonction du projet actif et respecte le format suivant : [USERNAME]@cloudshell:~ ([YOUR_PROJECT_NAME])$

  9. Lorsque vous y êtes invité, saisissez TOKEN=$(gcloud auth print-access-token) pour récupérer le jeton d'accès et le stocker en tant que variable.

  10. Lorsque vous y êtes invité, saisissez les commandes suivantes pour vous assurer que les variables $PROJECT et $TOKEN sont correctement définies :

    • echo $PROJECT
    • echo $TOKEN

Maintenant que vous avez défini vos variables, vous pouvez envoyer des requêtes à Datastream pour créer et gérer des profils de connexion et un flux.

Créer et gérer des profils de connexion

Dans cette section, vous allez créer et gérer des profils de connexion pour une base de données Oracle source et un bucket Cloud Storage de destination.

Lorsque vous créez ces profils de connexion, vous créez des enregistrements contenant des informations sur la base de données source et le bucket Cloud Storage de destination. Datastream utilise les informations des profils de connexion pour transférer les données de la base de données source vers un dossier du bucket de destination.

La création et la gestion des profils de connexion incluent les éléments suivants :

  • Créer des profils de connexion pour une base de données Oracle source et un bucket Cloud Storage de destination
  • Récupérer des informations sur un profil de connexion
  • Modifier un profil de connexion
  • Effectuer un appel d'API de découverte sur le profil de connexion Oracle source. Cet appel vous permet de consulter le contenu de la base de données afin de découvrir les objets qui lui sont associés. Ces objets incluent les schémas et les tables contenant les données de la base de données. Lorsque vous utilisez Datastream pour configurer un flux, vous souhaitez peut-être extraire un sous-ensemble d'objets plutôt que d'extraire l'intégralité des objets de la base de données (par exemple, seulement certains tableaux et schémas de la base de données). Utilisez l'API de découverte pour trouver (ou découvrir) le sous-ensemble d'objets de base de données que vous souhaitez extraire.

Créer des profils de connexion

Dans cette procédure, vous allez créer deux profils de connexion : l'un vers une base de données Oracle source et l'autre vers un bucket Cloud Storage de destination.

  1. Créez un profil de connexion à une base de données Oracle source. Lorsque vous y êtes invité, saisissez la commande suivante :

    ORACLE="{\"displayName\":\"[DISPLAY_NAME]\",\"oracle_profile\":{\"hostname\":\"[HOSTNAME],\"username\":\"[USERNAME]\",\"password\":\"[PASSWORD]\",\"database_service\":\"[DATABASE_SERVICE]\",\"port\":[PORT_NUMBER]},\"no_connectivity\":{}}"
    

    Utilisez le tableau suivant pour comprendre les valeurs des paramètres de la base de données Oracle source :

    Valeur du paramètreRemplacer par
    [DISPLAY_NAME]Nom à afficher du profil de connexion à la base de données source.
    [HOSTNAME]Nom d'hôte du serveur de base de données source.
    [USERNAME]Nom d'utilisateur du compte pour la base de données source (par exemple, ROOT).
    [PASSWORD]Mot de passe du compte pour la base de données source.
    [DATABASE_SERVICE]Service qui garantit que la base de données source est protégée et surveillée. Pour les bases de données Oracle, le service de base de données est généralement ORCL.
    [PORT_NUMBER]Numéro de port réservé à la base de données source. Pour une base de données Oracle, le numéro de port est généralement 1521.
  2. Lorsque vous y êtes invité, saisissez la commande echo $ORACLE | jq pour afficher le profil de connexion source que vous avez créé sous forme de texte facile à lire.

    {
      "displayName": "[DISPLAY_NAME]",
      "oracle_profile": {
        "hostname": "[HOSTNAME]",
        "username": "[USERNAME]",
        "password": "[PASSWORD]",
        "database_service": "[DATABASE_SERVICE]",
        "port": [PORT_NUMBER]
       },
      "no_connectivity": {}
    }
    
  3. Envoyez le profil de connexion Oracle afin qu'il puisse être créé. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X POST -d $ORACLE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles?connection_profile_id=[SOURCE_CONNECTION_PROFILE_ID]
    

    Utilisez le tableau suivant pour comprendre les valeurs des paramètres de cette commande :

    Valeur du paramètreRemplacer par
    [DATASTREAM_API_VERSION]Version actuelle de l'API Datastream (par exemple, v1).
    [PROJECT_PATH]Le chemin d'accès complet de votre projet Google Cloud (par exemple, projects/$PROJECT/locations/[YOUR_PROJECT_LOCATION]))
    [SOURCE_CONNECTION_PROFILE_ID]Identifiant unique réservé à ce profil de connexion (par exemple, cp-1).
  4. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[SOURCE_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "datastream.googleapis.com/[DATASREAM_VERSION]/[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  5. Créez un profil de connexion à un bucket Cloud Storage de destination. Lorsque vous y êtes invité, saisissez la commande suivante :

    GOOGLECLOUDSTORAGE="{\"displayName\":\"[DISPLAY_NAME]\",\"gcs_profile\":{\"bucket_name\":\"[BUCKET_NAME]\",\"root_path\":\"/[FOLDER_PATH]\"},\"no_connectivity\":{}}"
    

    Utilisez le tableau suivant pour comprendre les valeurs des paramètres du bucket de destination :

    Valeur du paramètreRemplacer par
    [DISPLAY_NAME]Nom à afficher du profil de connexion au bucket de destination.
    [BUCKET_NAME]Nom du bucket de destination.
    [FOLDER_PATH]Dossier du bucket de destination dans lequel Datastream transfère les données de la base de données source (par exemple, /root/path).
  6. Lorsque vous y êtes invité, saisissez la commande echo $GOOGLECLOUDSTORAGE | jq pour afficher le profil de connexion de destination que vous avez créé sous forme de texte facile à lire.

    {
      "displayName": "[DISPLAY_NAME]",
      "gcs_profile": {
        "bucket_name": "[BUCKET_NAME]",
        "root_path": "/[FOLDER_PATH]"
      },
      "no_connectivity": {}
    }
    
  7. Envoyez le profil de connexion Cloud Storage afin qu'il puisse être créé. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X POST -d $GOOGLECLOUDSTORAGE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles?connection_profile_id=[DESTINATION_CONNECTION_PROFILE_ID]
    
  8. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[DESTINATION_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "datastream.googleapis.com/[DATASREAM_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  9. Vérifiez que les deux profils de connexion ont bien été créés. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles
    
  10. Vérifiez que vous avez reçus deux résultats renvoyés pour les profils de connexion source et de destination.

    {
      "connectionProfiles": [
        {
          "name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "createTime": "[DATE_AND_TIME_STAMP]",
          "updateTime": "[DATE_AND_TIME_STAMP]",
          "displayName": "[DISPLAY_NAME]",
          "gcsProfile": {
            "bucketName": "[BUCKET_NAME]",
            "rootPath": "[FOLDER_PATH]"
          },
          "noConnectivity": {}
        },
       {
        "name": "[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "updateTime": "[DATE_AND_TIME_STAMP]",
        "displayName": "[DISPLAY_NAME]",
        "oracleProfile": {
          "hostname": "[HOSTNAME]",
          "port": [PORT_NUMBER],
          "username": "[USERNAME]",
          "databaseService": "[DATABASE_SERVICE]"
        },
        "noConnectivity": {}
        }
      ]
    }
    

Gérer les profils de connexion

Dans cette procédure, vous gérez les profils de connexion que vous avez créés pour une base de données Oracle source et un bucket Cloud Storage de destination. Par exemple :

  • Récupérer des informations sur le profil de connexion Cloud Storage de destination.
  • Modifier ce profil de connexion. Pour ce tutoriel, vous allez remplacer le dossier du bucket Cloud Storage de destination par /root/tutorial. Datastream transfère les données de la base de données source vers ce dossier.
  • Effectuer un appel d'API Discovery sur le profil de connexion Oracle source.
  1. Récupérer des informations sur le profil de connexion Cloud Storage de destination. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]
    
  2. Vérifier que les informations du profil de connexion s'affichent.

    {
      "name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "gcsProfile": {
        "bucketName": "[BUCKET_NAME]",
        "rootPath": "[FOLDER_PATH]"
      },
      "noConnectivity": {}
    }
    
  3. Modifier ce profil de connexion. Pour ce faire, commencez par définir une variable UPDATE. Cette variable contient les valeurs du profil de connexion que vous souhaitez modifier. Pour ce tutoriel, vous remplacerez le dossier du bucket de destination par /root/tutorial.

    Pour définir la variable, saisissez la commande suivante lorsque vous y êtes invité :

    UPDATE="{\"gcsProfile\":{\"rootPath\":\"/root/tutorial\"}}"
  4. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X PATCH -d $UPDATE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]?update_mask=gcsProfile.rootPath
    
  5. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[DESTINATION_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "verb": "update",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  6. Vérifier que le profil de connexion a bien été modifié. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]
    
  7. Vérifier que le dossier du bucket de destination du profil de connexion Cloud Storage est désormais /root/tutorial.

    {
      "name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "gcsProfile": {
        "bucketName": "[BUCKET_NAME]",
        "rootPath": "/root/tutorial"
      },
      "noConnectivity": {}
    }
    
  8. Utiliser l'API de découverte Datastream pour découvrir les schémas et les tables de la base de données source Oracle. Datastream permet d'accéder à cette base de données via le profil de connexion source.

    1. Découvrir les schémas de la base de données Oracle. Lorsque vous y êtes invité, saisissez la commande suivante :

      curl -X POST -d "{"connection_profile_name":"projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]"}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles:discover
        

    2. Vérifier que Datastream récupère tous les schémas de votre base de données.

    3. Récupérer les tables d'un schéma dans votre base de données. Pour ce tutoriel, vous utiliserez l'API de découverte pour récupérer les tables du schéma ROOT. Cependant, vous pouvez récupérer les tables de n'importe quel schéma de votre base de données.

      Lorsque vous y êtes invité, saisissez la commande suivante :

      curl -X POST -d "{\"connection_profile_name\":\"projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schemaName\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles:discover
      
    4. Vérifier que Datastream récupère toutes les tables du schéma que vous avez spécifié (pour ce tutoriel, le schéma ROOT).

Maintenant que vous avez créé et géré des profils de connexion pour une base de données Oracle source et un bucket Cloud Storage de destination, vous êtes prêt à créer et à gérer un flux dans Datastream.

Créer et gérer un flux

Dans cette section, vous allez créer et gérer un flux. Datastream utilise ce flux pour transférer des données, des schémas et des tables de la base de données source vers un dossier du bucket Cloud Storage de destination.

La création et la gestion d'un flux incluent :

  • La validation d'un flux pour vous assurer qu'il s'exécute correctement et que tous les contrôles de validation sont réussis. Ces vérifications incluent :
    • Si la source est correctement configurée pour autoriser Datastream à diffuser des données à partir de celle-ci.
    • Si le flux peut se connecter à la source et à la destination.
    • La configuration de bout en bout du flux.
  • La création du flux avec les listes suivantes :
    • Une liste d'autorisation. Cette liste répertorie les tables et les schémas de la base de données source que Datastream peut transférer dans un dossier du bucket Cloud Storage de destination. Pour ce tutoriel, il s'agit du dossier /root/tutorial.
    • Une liste de rejets. Cette liste répertorie les tables et les schémas de la base de données source que Datastream ne peut pas transférer dans le dossier du bucket Cloud Storage de destination.
  • La récupération d'informations sur le flux.
  • La modification du flux.
  • Le démarrage du flux afin que Datastream puisse transférer des données, des schémas et des tables de la base de données source vers un dossier du bucket Cloud Storage de destination.
  • L'utilisation de l'API Fetch Errors pour détecter les erreurs associées au flux.
  • La mise en pause du flux. Lorsqu'un flux est mis en pause, Datastream n'extrait pas les nouvelles données de la base de données source pour les transférer vers le bucket de destination.
  • Le rétablissement du flux mis en pause afin que Datastream puisse continuer à transférer des données vers le bucket de destination.

Créer un flux

Dans cette procédure, vous allez créer un flux à partir de la base de données Oracle source vers un dossier du bucket Cloud Storage de destination. Le flux que vous créez comprend une liste d'autorisation et une liste de refus.

  1. Définissez une variable SCHEMAS : Cette variable définit les schémas contenant les données et les tables que Datastream doit extraire de la base de données source et transférer dans le dossier /root/tutorial du bucket Cloud Storage de destination. Pour ce tutoriel, vous allez définir la variable SCHEMAS à associer au schéma ROOT.

    Lorsque vous y êtes invité, saisissez la commande suivante :

    SCHEMAS="{\"oracleSchemas\":[{\"schemaName\":\"ROOT\"}]}"
    
  2. Lorsque vous y êtes invité, saisissez la commande echo $SCHEMAS | jq pour afficher le schéma ROOT que vous avez défini pour cette variable sous forme de texte facile à lire.

  3. Créer un flux. Lorsque vous y êtes invité, saisissez la commande suivante :

    STREAM="{\"display_name\":\"[DISPLAY_NAME]\",\"source_config\":{\"source_connection_profile_name\":\"[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",\"oracle_source_config\":{\"allowlist\":$SCHEMAS,\"rejectlist\":{}}},\"destination_config\":{\"destination_connection_profile_name\":\"[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]\",\"gcs_destination_config\":{\"file_rotation_mb\":5,\"file_rotation_interval\":{\"seconds\":15},\"avro_file_format\":{}},\"backfill_all\":{}}"
    
  4. Lorsque vous y êtes invité, saisissez la commande echo $STREAM | jq pour afficher le flux que vous avez créé sous forme de texte facile à lire.

    {
      "display_name": "[DISPLAY_NAME]",
      "source_config": {
        "source_connection_profile_name": "[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracle_source_config": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destination_config": {
        "destination_connection_profile_name": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcs_destination_config": {
          "file_rotation_mb": 5,
          "file_rotation_interval": {
            "seconds": 15
          },
          "avro_file_format": {}
        }
      },
      "backfill_all": {}
    }
    

    Utilisez ce tableau pour comprendre les paramètres suivants du flux :

    ParamètreDescription
    allowlistLes schémas contenant des tables et des données qui seront transférés depuis la base de données source vers un dossier du bucket Cloud Storage de destination. Pour ce tutoriel, toutes les tables et toutes les données du schéma ROOT (et uniquement de ce schéma) seront transférées dans le dossier /root/tutorial du bucket de destination.
    rejectlistTous les schémas contenant des tables et des données qui ne seront pas transférés dans un dossier du bucket Cloud Storage de destination. Pour ce tutoriel, la valeur {} signifie qu'aucune table ni aucunes données de la base de données source ne pourront être transférées dans le bucket de destination.
    file_rotation_mbTaille (en Mo) des fichiers contenant des données en cours de transfert depuis la base de données source vers un dossier du bucket Cloud Storage de destination. Pour ce tutoriel, les données étant extraites de la base de données source, elles sont écrites dans des fichiers de 5 Mo. Si des données dépassent cette taille, elles seront segmentées en plusieurs fichiers de 5 Mo.
    file_rotation_intervalNombre de secondes qui s'écoulent avant que Datastream ne ferme un fichier existant dans un dossier du bucket Cloud Storage de destination et ouvre un autre fichier pour contenir les données transférées à partir de la base de données source. Dans le cadre de ce tutoriel, l'intervalle de rotation des fichiers est défini sur 15 secondes.
    avro_file_format

    Format des fichiers que Datastream transfère de la base de données source vers un dossier du bucket Cloud Storage de destination. Pour ce tutoriel, Avro est le format de fichier.

    backfill_all

    Ce paramètre est associé à un remplissage de données d'historique. Si vous définissez ce paramètre sur un dictionnaire vide ({}), DataStream remplira les champs suivants :

    • Données d'historique, en plus des modifications en cours sur les données, de la base de données source vers la destination
    • Schémas et tables, de la source vers la destination.
  5. Validez le flux pour vous assurer qu'il s'exécute correctement et que tous les contrôles de validation sont réussis. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X POST -d $STREAM -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" "https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams?stream_id=[STREAM_ID]&validate_only=true"
    
  6. Vérifiez que la ligne de code {} s'affiche. Cela indique que le flux a réussi tous les contrôles de validation et qu'aucune erreur n'est associée au flux.

  7. Envoyez le flux afin qu'il puisse être créé. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X POST -d $STREAM -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams?stream_id=[STREAM_ID]
    
  8. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "create",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  9. Vérifiez que le flux a bien été créé. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams
    
  10. Vérifiez que vous recevez bien un résultat pour le flux que vous avez créé.

    {
      "streams": [
        {
          "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
          "createTime": "[DATE_AND_TIME_STAMP]",
          "updateTime": "[DATE_AND_TIME_STAMP]",
          "displayName": "[DISPLAY_NAME]",
          "sourceConfig": {
            "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
            "oracleSourceConfig": {
              "allowlist": {
                "oracleSchemas": [
                  {
                    "schemaName": "ROOT"
                  }
                ]
              },
              "rejectlist": {}
            }
          },
          "destinationConfig": {
            "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "gcsDestinationConfig": {
              "fileRotationMb": 5,
              "fileRotationInterval": "15s"
              "avroFileFormat": {}
            }
          },
          "state": "CREATED",
          "backfillAll": {}
        }
      ]
    }
    

Gérer le flux

Dans cette procédure, vous utilisez le flux que vous avez créé pour transférer des données d'une base de données Oracle source vers un dossier dans un bucket Cloud Storage de destination. Par exemple :

  • La récupération d'informations sur le flux.
  • La modification du flux.
  • Le démarrage du flux.
  • L'utilisation de l'API Fetch Errors pour détecter les erreurs associées au flux.
  • La mise en pause et le rétablissement du flux.
  1. Récupérez des informations sur le flux. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  2. Vérifiez que les informations concernant le flux s'affichent correctement.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
         }
        },
        "destinationConfig": {
          "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "gcsDestinationConfig": {
            "fileRotationMb": 5,
            "fileRotationInterval": "15s"
            "avroFileFormat": {}
          }
        },
        "state": "CREATED",
        "backfillAll": {}
      }
    
  3. Modifiez ce flux. Pour ce faire, commencez par définir une variable UPDATE. Cette variable contient les valeurs du flux que vous souhaitez modifier. Pour ce tutoriel, modifiez la taille (en Mo) des fichiers contenant des données transférées de la base de données source vers un dossier du bucket Cloud Storage de destination (de 5 à 100 Mo). Lorsque les données sont extraites de la base de données source, elles sont désormais écrites dans des fichiers de 100 Mo. Si des données dépassent cette taille, elles seront segmentées en plusieurs fichiers de 100 Mo.

    Pour définir la variable, saisissez la commande suivante lorsque vous y êtes invité :

    UPDATE="{\"destination_config\":{\"gcs_destination_config\":{\"file_rotation_mb\":100}}}"
    
  4. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X PATCH -d $UPDATE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]/?update_mask=destination_config.gcs_destination_config.file_rotation_mb
    
  5. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "update",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  6. Vérifiez que le flux a bien été modifié. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  7. Vérifiez que la valeur du paramètre fileRotationMb du profil de connexion Cloud Storage est désormais 100.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
         }
        },
        "destinationConfig": {
          "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
          "gcsDestinationConfig": {
            "fileRotationMb": 100,
            "fileRotationInterval": "15s"
            "avroFileFormat": {}
          }
        },
        "state": "CREATED",
        "backfillAll": {}
      }
    
  8. Démarrez le flux. Pour ce faire :

    1. Modifiez la variable UPDATE. Lorsque vous y êtes invité, saisissez la commande suivante :

      UPDATE="{\"state\":\"RUNNING\"}"
      
    2. Saisissez ensuite la commande suivante :

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]?updateMask=state
      
  9. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "start",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  10. Après quelques minutes, récupérez des informations sur le flux pour vérifier qu'il a bien démarré.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  11. Vérifiez que l'état du flux est passé de CREATED à RUNNING.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcsDestinationConfig": {
          "fileRotationMb": 100,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "RUNNING",
      "backfillAll": {}
    }
    
  12. Utilisez l'API Fetch Errors pour récupérer les erreurs associées au flux.

    1. Lorsque vous y êtes invité, saisissez la commande suivante :

      curl -X POST -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]:fetchErrors
        

    2. Vérifiez que les lignes de code suivantes s'affichent :

        {
          "name": "[PROJECT_PATH]/operations/operation-[FETCH_ERRORS_OPERATION_ID]",
          "metadata": {
            "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
            "createTime": "[DATE_AND_TIME_STAMP]",
            "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
            "verb": "fetchErrors",
            "requestedCancellation": false,
            "apiVersion": "[DATASTREAM_API_VERSION]"
          },
          "done": false
        }
        

    3. Lorsque vous y êtes invité, saisissez la commande suivante :

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/operations/operation-[FETCH_ERRORS_OPERATION_ID]
        

    4. Vérifiez que les lignes de code suivantes s'affichent :

        {
          "name": "[PROJECT_PATH]/operations/operation-[FETCH_ERRORS_OPERATION_ID]",
          "metadata": {
            "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
            "createTime": "[DATE_AND_TIME_STAMP]",
            "endTime": "[DATE_AND_TIME_STAMP]",
            "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
            "verb": "fetchErrors",
            "requestedCancellation": false,
            "apiVersion": "[DATASTREAM_API_VERSION]"
          },
          "done": true,
          "response": {
            "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].FetchErrorsResponse"
          }
        }
        

  13. Mettre le flux en pause. Pour ce faire :

    1. Modifiez la variable UPDATE. Lorsque vous y êtes invité, saisissez la commande suivante :

      UPDATE="{\"state\":\"PAUSED\"}"
      
    2. Saisissez ensuite la commande suivante :

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]?updateMask=state
      
  14. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "start",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  15. Récupérez des informations sur le flux pour vérifier qu'il a bien été mis en pause.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  16. Vérifiez que l'état du flux est passé de RUNNING à PAUSED.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcsDestinationConfig": {
          "fileRotationMb": 100,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "PAUSED",
      "backfillAll": {}
    }
    
  17. Relancez le flux mis en pause. Pour ce faire :

    1. Modifiez la variable UPDATE. Lorsque vous y êtes invité, saisissez la commande suivante :

      UPDATE="{\"state\":\"RUNNING\"}"
      
    2. Saisissez ensuite la commande suivante :

      curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]?updateMask=state
      
  18. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "start",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  19. Attendez quelques secondes, puis récupérez les informations sur le flux afin de vérifier qu'il s'exécute à nouveau.

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  20. Vérifiez que l'état du flux est repassé de PAUSED à RUNNING.

    {
      "name": "[PROJECT_PATH]/streams/[STREAM_ID]",
      "createTime": "[DATE_AND_TIME_STAMP]",
      "updateTime": "[DATE_AND_TIME_STAMP]",
      "displayName": "[DISPLAY_NAME]",
      "sourceConfig": {
        "sourceConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "oracleSourceConfig": {
          "allowlist": {
            "oracleSchemas": [
              {
                "schemaName": "ROOT"
              }
            ]
          },
          "rejectlist": {}
        }
      },
      "destinationConfig": {
        "destinationConnectionProfileName": "projects/[YOUR_PROJECT_NUMBER]/locations/[YOUR_PROJECT_LOCATION]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "gcsDestinationConfig": {
          "fileRotationMb": 100,
          "fileRotationInterval": "15s"
          "avroFileFormat": {}
        }
      },
      "state": "RUNNING",
      "backfillAll": {}
    }
    

Maintenant que vous avez créé et géré un flux, vérifié qu'il n'y a pas d'erreur associée au flux et que son état est RUNNING, vous êtes prêt à vérifier qu'il peut transférer des données de la base de données source vers un dossier dans le bucket Cloud Storage de destination.

Vérifier le flux

Dans cette procédure, vous confirmez que Datastream :

  • Transfère les données de toutes les tables associées au schéma ROOT de votre base de données Oracle source vers le dossier /root/tutorial du bucket Cloud Storage de destination.
  • Convertit les données au format de fichier Avro.
  1. Accédez à la page Navigateur de stockage de Cloud Storage.

    Accéder à la page du navigateur Cloud Storage

  2. Cliquez sur le lien contenant votre bucket.

  3. Si l'onglet OBJETS n'est pas actif, cliquez dessus.

  4. Cliquez sur le dossier root, puis sur le dossier tutorial.

  5. Vérifiez que les dossiers représentent les tables du schéma ROOT de votre base de données Oracle source.

  6. Cliquez sur l'un des dossiers de la table et accédez aux données associées.

  7. Cliquez sur un fichier qui représente les données, puis sur Télécharger.

  8. Ouvrez ce fichier dans un outil Avro (par exemple, Avro Viewer) pour vous assurer que le contenu est lisible. Cela confirme également que Datastream a bien traduit les données au format de fichier Avro.

Effectuer un nettoyage

Une fois que vous avez terminé ce tutoriel, vous pouvez nettoyer les ressources que vous avez créées sur Datastream afin qu'elles ne soient plus comptabilisées dans le quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

  1. Dans Cloud Console, accédez à la page Gérer les ressources.

    Accéder à la page Gérer les ressources

  2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer le bucket Cloud Storage de destination

  1. Dans le panneau de navigation de gauche de Cloud Storage, cliquez sur l'élément Navigateur.

  2. Cochez la case située à gauche de votre bucket, puis cliquez sur SUPPRIMER.

  3. Dans la fenêtre "Supprimer le bucket ?", saisissez le nom de votre bucket dans la zone de texte puis cliquez sur CONFIRMER.

Supprimer le flux

  1. Assurez-vous que votre application Cloud Shell est active.

  2. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams/[STREAM_ID]
    
  3. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[STREAM_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/streams/[STREAM_ID]",
        "verb": "delete",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  4. Confirmez la suppression du flux. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/streams
    
  5. Vérifiez qu'une valeur {} nulle est renvoyée. Cela signifie qu'il n'y a plus de flux dans Datastream et que le flux que vous avez créé a bien été supprimé.

Supprimer les profils de connexion

  1. Supprimez le profil de connexion à la base de données Oracle source. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]
    
  2. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[SOURCE_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/connectionProfiles/[SOURCE_CONNECTION_PROFILE_ID]",
        "verb": "delete",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  3. Supprimez le profil de connexion au bucket Cloud Storage de destination. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -X DELETE -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]
    
  4. Vérifiez que les lignes de code suivantes s'affichent :

    {
      "name": "[PROJECT_PATH]/operations/operation-[DESTINATION_CONNECTION_PROFILE_OPERATION_ID]",
      "metadata": {
        "@type": "type.googleapis.com/google.cloud.datastream.[DATASTREAM_API_VERSION].OperationMetadata",
        "createTime": "[DATE_AND_TIME_STAMP]",
        "target": "[PROJECT_PATH]/connectionProfiles/[DESTINATION_CONNECTION_PROFILE_ID]",
        "verb": "delete",
        "requestedCancellation": false,
        "apiVersion": "[DATASTREAM_API_VERSION]"
      },
      "done": false
    }
    
  5. Vérifiez que les deux profils de connexion ont bien été supprimés. Lorsque vous y êtes invité, saisissez la commande suivante :

    curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/[DATASTREAM_API_VERSION]/[PROJECT_PATH]/connectionProfiles
    
  6. Vérifiez qu'une valeur {} nulle est renvoyée. Cela signifie qu'il n'y a plus de profils de connexion dans Datastream et que les profils que vous avez créés ont bien été supprimés.

Étape suivante

  • En savoir plus sur Datastream.
  • Testez d'autres fonctionnalités de Google Cloud. Découvrez nos tutoriels.