Utiliser les API Datastream

Datastream

Présentation

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 temps quasi réel pour modifier les données à partir de diverses sources de données sur site et dans le 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 qui démocratise l'accès de l'entreprise aux données d'entreprise les plus récentes disponibles dans l'ensemble de l'entreprise, en fournissant des scénarios intégrés quasiment en 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 données 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

Dans ce document, vous utilisez 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

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.

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

Vérifiez que la facturation est activée pour votre projet Google Cloud.

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

Vérifiez que la facturation est activée pour votre projet Google Cloud.

Activez l'API Datastream.
Activer l'API
Assurez-vous que le rôle "Administrateur de flux de données" est attribué à votre compte utilisateur.
Accéder à la page IAM
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.
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.
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.
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.
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.
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 permettant à Cloud Shell d'effectuer des tâches dans Datastream à l'aide des API REST.

Lancez votre application Cloud Shell.
Une fois authentifié dans votre application avec votre compte Google, saisissez gcloud auth login.
Lorsque l'invite Do you want to continue (Y/n)? s'affiche, saisissez Y.
Ouvrez un navigateur Web et copiez l'URL dans le navigateur.
Authentifiez-vous auprès de Google Cloud SDK avec votre compte Google. Un code apparaît sur la page Connexion. Ce code est votre jeton d'accès.
Copiez le jeton d'accès, collez-le dans le paramètre Enter verification code: de votre application Cloud Shell, puis appuyez sur Enter.
Lorsque vous y êtes invité, saisissez PROJECT="YOUR_PROJECT_NAME" pour définir la variable d'environnement $PROJECT sur votre projet Google Cloud.
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 pour refléter votre projet actif et respecte le format suivant: USERNAME@cloudshell:~ (YOUR_PROJECT_NAME)$
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.
Lorsque vous y êtes invité, saisissez les commandes suivantes pour vous assurer que vos 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.

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ètre	Remplacer 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.

Remarque : Pour ce tutoriel, la méthode de connectivité réseau utilisée est no_connectivity, car vous avez configuré votre base de données Oracle source pour autoriser les connexions entrantes provenant d'adresses IP publiques Datastream. Outre no_connectivity, il existe deux méthodes de connectivité réseau que vous pouvez utiliser pour établir une connexion entre la base de données source et le dossier du bucket Cloud Storage de destination.

Liste d'autorisation d'adresses IP : cette méthode configure la base de données source pour accepter les connexions issues de l'adresse IP publique de Datastream. Si vous utilisez la liste d'autorisation d'adresses IP comme méthode de connectivité réseau, remplacez no_connectivity par StaticIpConnectivity.
Tunnel SSH de transfert : cette méthode établit la connectivité de la base de données source vers Datastream via un tunnel SSH sécurisé. Si vous utilisez le tunnel SSH de transfert comme méthode de connectivité réseau, remplacez no_connectivity par forwardSshTunnelConnectivity. Pour plus d'informations sur les valeurs que vous pouvez définir pour cette méthode de connectivité réseau, consultez la documentation de référence.

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": {}
}

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ètre	Remplacer par
`DATASTREAM_API_VERSION`	Version actuelle de l'API Datastream (par exemple, `v1`).
`PROJECT_PATH`	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`).

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
}

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ètre	Remplacer 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`).

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": {}
}
```
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
```
Important : Pour la valeur du paramètre DESTINATION_CONNECTION_PROFILE_ID, veillez à spécifier un autre identifiant pour ce profil de connexion (par exemple, cp-2).

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/DATASTREAM_VERSION/PROJECT_PATH/connectionProfiles/DESTINATION_CONNECTION_PROFILE_ID",
    "verb": "create",
    "requestedCancellation": false,
    "apiVersion": "DATASTREAM_API_VERSION"
  },
  "done": false
}

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
```
Remarque : La chaîne connectionProfiles à la fin de la commande indique que vous souhaitez récupérer des informations sur les deux profils de connexion pour vérifier qu'ils ont été créés.

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.

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

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": {}
}

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

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

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
}

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

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": {}
}

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\", \"oracle_rdbms\":{\"oracleSchemas\":[{\"schema\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles:discover
```
  Remarque : Remplacez l'espace réservé YOUR_PROJECT_NUMBER par le numéro d'identification à 10 chiffres de votre projet Google Cloud. La portion connectionProfiles:discover du code indique que vous souhaitez utiliser le profil de connexion de la base de données Oracle source pour découvrir tous les schémas de cette base de données.
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\":[{\"schema\":\"ROOT\"}]}}" -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/connectionProfiles:discover
```
1. 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.
Réactivez le flux mis en pause pour 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.

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\":[{\"schema\":\"ROOT\"}]}"
```
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.

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\":{}}}"

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": [
          {
            "schema": "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ètres	Description
`allowlist`	Les 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.
`rejectlist`	Tous 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_mb`	Taille (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_interval`	Nombre 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. En plus de Avro, Datastream est désormais compatible avec le format de sortie JSON pour les fichiers écrits dans Cloud Storage. Au lieu de `avro_file_format`, il est représenté par le paramètre `json_file_format`. Pour le format JSON, vous pouvez : Incluez un fichier de schéma de types unifiés dans le chemin. Par conséquent, Datastream écrit deux fichiers dans Cloud Storage : un fichier de données JSON et un fichier de schéma Avro. Le fichier de schéma porte le même nom que le fichier de données, avec une extension `.schema`. Activez la compression gzip pour que Datastream compresse les fichiers écrits dans Cloud Storage. Comme ces deux propriétés ne s'appliquent pas à Avro, la valeur du paramètre `avro_file_format` est définie sur un dictionnaire vide (`{}`).
`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.

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"
```
Remplacez la valeur du paramètre STREAM_ID par un identifiant unique réservé à ce flux (par exemple, stream-1).

La valeur &validate_only=true indique que vous validez uniquement le flux. Vous ne le créez pas. Dans le cas de cette requête, placez l'URL complète entre guillemets. Ainsi, Datastream récupérera la valeur &validate_only=true pour valider le flux.
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.

Si un contrôle échoue, des informations indiquent la raison de l'échec et la procédure à suivre pour corriger le problème.

Une fois les corrections appropriées effectuées, relancez la requête pour vous assurer que tous les contrôles de validation réussissent.

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

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
}

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
```
Remarque : La chaîne streams à la fin de la commande indique que vous souhaitez récupérer des informations sur le flux pour confirmer qu'il a bien été créé.

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": [
              {
                "schema": "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.

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

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": [
          {
            "schema": "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": {}
  }

Modifier 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 les données transférées depuis la base de données source vers un dossier du bucket de destination Cloud Storage (de 5 Mo à 100 Mo). Lorsque les données sont extraites de la base de données source, elles sont maintenant écrites dans des fichiers de 100 Mo. Si certaines données dépassent cette taille, elles sont 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}}}"
```
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
```
Remarque : La portion update_mask=destination_config.gcs_destination_config.file_rotation_mb du code indique que vous souhaitez changer la valeur du paramètre file_rotation_mb du profil de connexion Cloud Storage.

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
}

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

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": [
          {
            "schema": "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": {}
  }

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
```
  Si vous utilisez le paramètre updateMask dans la requête, seuls les champs que vous spécifiez doivent être inclus dans le corps de la requête.
  
  Pour cet exemple, le champ spécifié est le champ state, qui représente l'état du flux. En démarrant le flux, vous passez de l'état CREATED à RUNNING.

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
}

Après quelques minutes, récupérez les informations sur la diffusion pour vérifier qu'elle a commencé:
```
curl -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" https://datastream.googleapis.com/DATASTREAM_API_VERSION/PROJECT_PATH/streams/STREAM_ID
```
Remarque : Le démarrage du flux prend quelques minutes. Les ressources d'arrière-plan doivent démarrer pour que le flux puisse démarrer.

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": [
          {
            "schema": "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": {}
}

Utilisez l'API Fetch Errors pour récupérer les erreurs associées au flux.

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

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
  }

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

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"
    }
  }
  
```
Remarque : Aucune erreur n'apparaît après la ligne de code "@type": "type.googleapis.com/google.cloud.datastream.DATASTREAM_API_VERSION.FetchErrorsResponse. Cela indique que Datastream n'a détecté aucune erreur pour le flux. Vous pouvez utiliser le flux pour transférer des données de la base de données Oracle source vers le dossier /root/tutorial du bucket Cloud Storage de destination. Voici un exemple d'erreur pouvant être récupérée à l'aide de l'API Fetch Errors : BAD_CREDENTIALS. Cette erreur se produit lorsqu'une valeur non valide est présente dans les profils de connexion source ou de destination et que Datastream ne peut pas se connecter à la base de données source ou au bucket Cloud Storage de destination.

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
```
  En mettant le flux en pause, vous passez de l'état RUNNING à PAUSED.

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
}

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

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": [
          {
            "schema": "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": {}
}

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
```
  En rétablissant le flux, vous modifiez son état de PAUSED à RUNNING.

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
}

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

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": [
          {
            "schema": "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.

Accédez à la page Navigateur de stockage de Cloud Storage.

Accéder à la page du navigateur Cloud Storage
Cliquez sur le lien contenant votre bucket.
Si l'onglet OBJETS n'est pas actif, cliquez dessus.
Cliquez sur le dossier root, puis sur le dossier tutorial.

Remarque : Datastream a créé les dossiers root et tutorial après avoir modifié le profil de connexion de destination en modifiant le bucket de destination pour utiliser /root/tutorial.
Vérifiez que les dossiers représentent les tables du schéma ROOT de votre base de données Oracle source.
Cliquez sur l'un des dossiers de la table et accédez aux données associées.
Cliquez sur un fichier qui représente les données, puis sur Télécharger.
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 :

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches de ce document, lorsque vous le supprimez, vous supprimez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
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

Dans le panneau de navigation de gauche de Cloud Storage, cliquez sur l'élément Navigateur.
Cochez la case située à gauche du bucket, puis cliquez sur SUPPRIMER.
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

Assurez-vous que votre application Cloud Shell est active.

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

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
}

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

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

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

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
}

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

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
}

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

Vérifiez qu'une valeur {} nulle a été 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 été supprimés.

Étapes suivantes

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

Mappages de types unifiés

Gérer les tags à l'aide de l'API