GSP925

Présentation

L'API Document AI est une solution de reconnaissance de documents qui permet de mieux comprendre, analyser et utiliser des données non structurées, telles que des documents et des e-mails.

Dans cet atelier, vous allez utiliser l'API Document AI avec du code Python pour créer différents processeurs, dont un processeur de formulaires général et un processeur de reconnaissance optique des caractères (OCR, Optical Character Recognition) dans les documents. Ensuite, vous effectuerez des appels synchrones et asynchrones vers l'API en Python. Dans cet atelier, vous allez créer une instance Vertex AI Workbench que vous utiliserez avec des notebooks JupyterLab pour travailler avec les modules clients Python pour Document AI.

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Activer l'API Document AI et créer des processeurs
• Installer la bibliothèque cliente pour Python dans une instance Vertex AI Workbench
• Analyser les données d'un formulaire scanné en effectuant un appel d'API synchrone en Python
• Analyser les données de formulaires scannés pour effectuer un appel d'API asynchrone en Python

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

2. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Tâche 1 : Créer et tester un processeur de formulaires général

Dans cette tâche, vous allez activer l'API Document AI avant de créer et de tester un processeur de formulaires général. Ce processeur pourra traiter tous types de documents et extraire tous les contenus textuels qu'il identifie dans un document. Il ne se limite pas au texte imprimé. Il peut traiter du texte manuscrit ou orienté dans n'importe quel sens. De plus, ce processeur prend en charge plusieurs langues. Il comprend aussi comment les éléments de données des formulaires sont liés les uns aux autres, afin que vous puissiez extraire des paires clé/valeur des champs de formulaire assortis d'étiquettes textuelles.

Activer l'API Cloud Document AI

Avant de pouvoir utiliser Document AI, vous devez activer l'API.

1. Dans la console Cloud, accédez au menu de navigation (), puis cliquez sur API et services > Bibliothèque.

2. Recherchez API Cloud Document AI, puis cliquez sur le bouton Activer pour pouvoir utiliser l'API dans votre projet Google Cloud.

Si elle est déjà activée, un bouton Gérer apparaît à la place. Vous pouvez alors passer à la suite de l'atelier.

Vérifier que l'API Cloud Document AI est activée

Créer un processeur de formulaires général

Créez un processeur Document AI à l'aide de l'analyseur de formulaires Document AI.

1. Dans le menu de navigation de la console (), cliquez sur Document AI > Aperçu.

2. Cliquez sur Découvrir le processeur, puis sélectionnez Analyseur de formulaires, qui est un type de processeur général.

3. Indiquez form-parser comme nom de processeur et sélectionnez la région US (États-Unis) dans la liste.

4. Cliquez sur Créer pour créer le processeur général form-parser.

Cette opération va créer le processeur et afficher de nouveau la page d'informations le concernant. Sur cette page, vous trouverez l'identifiant du processeur, son état et le point de terminaison de prédiction.

5. Notez cet identifiant, car vous devrez l'insérer dans des variables de notebooks JupyterLab lors de plusieurs tâches.

Tâche 2 : Configurer l'instance Vertex AI Workbench pour appeler l'API Document AI

Connectez-vous ensuite à l'environnement JupyterLab qui s'exécute dans l'instance Vertex AI Workbench créée pour vous au début de l'atelier, puis configurez-le pour les autres tâches de l'atelier.

1. Dans la console Google Cloud, accédez au menu de navigation et cliquez sur Vertex AI > Workbench.

2. Recherchez l'instance , puis cliquez sur le bouton Ouvrir JupyterLab.

L'interface JupyterLab de votre instance Workbench s'ouvre dans un nouvel onglet de navigateur.

3. Cliquez sur Terminal pour ouvrir un shell de terminal dans l'instance Vertex AI Workbench.

4. Saisissez la commande suivante dans le shell de terminal pour importer les fichiers de l'atelier dans votre instance Vertex AI Workbench :

gsutil cp {{{project_0.startup_script.notebook_files_path|notebook_files_path}}} .

5. Saisissez la commande suivante dans le shell de terminal pour installer les bibliothèques clientes Python dont a besoin Document AI, ainsi que les autres bibliothèques requises :

python -m pip install --upgrade google-cloud-core google-cloud-documentai google-cloud-storage prettytable

Le résultat qui s'affiche doit indiquer que les bibliothèques ont bien été installées.

Remarque : En cas d'erreurs liées aux autorisations, réexécutez la commande pour que l'installation des bibliothèques réussisse. L'application des autorisations peut prendre quelques minutes.

6. Saisissez la commande suivante dans le shell de terminal pour importer l'exemple de formulaire médical d'admission :

gsutil cp {{{project_0.startup_script.health_intake_form_path|form_path}}} form.pdf

7. Dans l'interface du notebook, ouvrez le notebook JupyterLab nommé .

8. Dans la boîte de dialogue Select Kernel (Sélectionner le kernel), sélectionnez Python 3 dans la liste des kernels disponibles.

Vérifier que l'instance Vertex AI a bien été préparée pour effectuer des appels synchrones vers l'API Document AI

Tâche 3 : Envoyer une requête de traitement de document synchrone

Réalisez un appel de traitement de document en effectuant un appel synchrone vers l'API Document AI. Pour traiter des volumes importants de documents simultanément, vous pouvez également utiliser l'API asynchrone dont vous vous servirez lors d'une autre tâche.

Vérifier le code Python pour les appels synchrones vers l'API Document AI

Prenez quelques instants pour passer en revue le code Python dans le notebook .

Le premier bloc de code importe les bibliothèques nécessaires et initialise certaines variables.

from google.cloud import documentai_v1beta3 as documentai from google.cloud import storage from prettytable import PrettyTable project_id = %system gcloud config get-value core/project project_id = project_id[0] location = 'us' file_path = 'form.pdf'

La cellule de code Set your Processor ID précise l'identifiant de processeur que vous avez défini manuellement avant que vous puissiez traiter des documents avec le notebook.

processor_id = 'PROCESSOR_ID' # TODO: Replace with a valid Processor ID

À cette étape, vous aurez besoin de l'identifiant de processeur Document AI du processeur que vous avez créé lors de la tâche 1.

Astuce : Si vous n'avez pas noté cet identifiant, dans l'onglet de la console Cloud, ouvrez le menu de navigation (), cliquez sur Document AI > Mes processeurs, puis cliquez sur le nom de votre processeur pour ouvrir la page d'informations. Vous pourrez alors copier l'identifiant du processeur.

La cellule de code Process Document Function définit la fonction process_document qui sert à effectuer un appel synchrone vers un processeur Document AI. Cette fonction crée un objet client API Document AI.

Le nom de processeur requis par l'appel d'API est créé à l'aide des paramètres project_id, locations et processor_id. L'exemple de document PDF est lu et stocké dans une structure mime_type.

La fonction crée un objet "request" qui contient le nom complet du processeur du document et utilise cet objet comme paramètre pour effectuer un appel synchrone vers le client API Document AI. Si la requête aboutit, l'objet "document" renvoyé inclut les propriétés qui contiennent les entités détectées dans le formulaire.

def process_document( project_id=project_id, location=location, processor_id=processor_id, file_path=file_path ): # Instantiates a client client = documentai.DocumentProcessorServiceClient() # The full resource name of the processor, e.g.: # projects/project-id/locations/location/processor/processor-id # You must create new processors in the Cloud Console first name = f"projects/{project_id}/locations/{location}/processors/{processor_id}" with open(file_path, "rb") as image: image_content = image.read() # Read the file into memory document = {"content": image_content, "mime_type": "application/pdf"} # Configure the process request request = {"name": name, "document": document} # Use the Document AI client to process the sample form result = client.process_document(request=request) return result.document

La cellule de code Process Document appelle la fonction process_document, enregistre la réponse dans la variable document et affiche le texte brut détecté. Tous les processeurs signaleront des données pour la propriété document.text.

document=process_document() # print all detected text. # All document processors will display the text content print("Document processing complete.") print("Text: {}".format(document.text))

La cellule de code Get Text Function définit la fonction get_text() qui récupère le texte d'un élément nommé à l'aide des propriétés text_anchor, start_index et end_index des text_segments de cet élément. Cette fonction sert à récupérer le nom et la valeur de formulaire pour les données du formulaire si ces données sont renvoyées par le processeur.

def get_text(doc_element: dict, document: dict): """ Document AI identifies form fields by their offsets in document text. This function converts offsets to text snippets. """ response = "" # If a text segment spans several lines, it will # be stored in different text segments. for segment in doc_element.text_anchor.text_segments: start_index = ( int(segment.start_index) if segment in doc_element.text_anchor.text_segments else 0 ) end_index = int(segment.end_index) response += document.text[start_index:end_index] return response

La cellule Display Form Data effectue une itération sur toutes les pages qui ont été détectées. Pour chaque champ form_field détecté, elle utilise la fonction get_text() afin de récupérer le nom et la valeur du champ. Ces valeurs sont ensuite affichées, avec les scores de confiance correspondants. Les processeurs qui utilisent l'analyseur de formulaires général ou les analyseurs spécialisés renverront des données de formulaire, mais pas les processeurs créés à l'aide de l'analyseur par OCR dans les documents.

document_pages = document.pages print("Form data detected:\n") # For each page fetch each form field and display fieldname, value and confidence scores for page in document_pages: print("Page Number:{}".format(page.page_number)) for form_field in page.form_fields: fieldName=get_text(form_field.field_name,document) nameConfidence = round(form_field.field_name.confidence,4) fieldValue = get_text(form_field.field_value,document) valueConfidence = round(form_field.field_value.confidence,4) print(fieldName+fieldValue +" (Confidence Scores: (Name) "+str(nameConfidence)+", (Value) "+str(valueConfidence)+")\n")

La cellule Display Entity Data extrait les données des entités de l'objet "document" et affiche le type d'entité, la valeur et les scores de confiance de chaque entité détectée. Seuls les processeurs qui utilisent des analyseurs spécialisés de Document AI (comme l'analyseur des dépenses liées à l'approvisionnement) renvoient des données d'entité. L'analyseur de formulaires général et l'analyseur par OCR dans les documents ne renvoient pas de données d'entité.

if 'entities' in dir(document): entities = document.entities # Grab each key/value pair and their confidence scores. table = PrettyTable(['Type', 'Value', 'Confidence']) for entity in entities: entity_type = entity.type_ value = entity.mention_text confience = round(entity.confidence,4) table.add_row([entity_type, value, confience]) print(table) else: print("Document does not contain entity data.")

Tâche 4 : Exécuter le code Python synchrone pour Document AI

Exécutez le code pour effectuer des appels synchrones vers l'API Document AI dans le notebook JupyterLab.

1. Dans la deuxième cellule de code Set your Processor ID, remplacez le texte de l'espace réservé PROCESSOR_ID par l'identifiant du processeur form-parser que vous avez créé précédemment.

2. Sélectionnez la première cellule, cliquez sur le menu Run (Exécuter), puis sur Run Selected Cell and All Below (Exécuter la cellule sélectionnée et les suivantes) pour exécuter tout le code du notebook.

Si vous avez utilisé l'exemple de formulaire médical d'admission, vous verrez s'afficher des données semblables aux suivantes dans la cellule de sortie contenant les données du formulaire :

Form data detected: Page Number:1 Phone #: (906) 917-3486 (Confidence Scores: (Name) 1.0, (Value) 1.0) ... Date: 9/14/19 (Confidence Scores: (Name) 0.9999, (Value) 0.9999) ... Name: Sally Walker (Confidence Scores: (Name) 0.9973, (Value) 0.9973) ...

Si vous parvenez à créer un processeur spécialisé, la dernière cellule affichera les données des entités. Dans le cas contraire, vous obtiendrez une table vide.

3. Dans le menu JupyterLab, cliquez sur File (Fichier), puis sur Save Notebook (Enregistrer le notebook) pour enregistrer votre progression.

Vérifier qu'un document a bien été traité à l'aide de l'API Cloud Document AI synchrone

Tâche 5 : Créer un processeur d'OCR dans les documents pour Document AI

Dans cette tâche, vous allez créer un processeur Document AI à l'aide de l'analyseur général par OCR dans les documents.

1. Dans le menu de navigation, cliquez sur Document AI > Aperçu.

2. Cliquez sur Découvrir le processeur, puis sur Créer un processeur de type OCR dans les documents. Il s'agit d'un type de processeur général.

3. Indiquez ocr-processor comme nom de processeur et sélectionnez la région US (États-Unis) dans la liste.

4. Cliquez sur Créer pour créer le processeur.

5. Notez l'identifiant du processeur. Vous en aurez besoin lors d'une autre tâche.

Tâche 6 : Préparer votre environnement pour effectuer des appels asynchrones vers l'API Document AI

Dans cette tâche, vous allez importer l'exemple de notebook JupyterLab pour tester les appels asynchrones vers l'API Document AI. Vous allez également copier quelques exemples de formulaires nécessaires pour l'atelier dans Cloud Storage afin d'effectuer un traitement asynchrone.

1. Cliquez sur l'onglet Terminal pour rouvrir le shell de terminal dans l'instance Vertex AI Workbench.

2. Créez un bucket Cloud Storage pour les documents d'entrée, puis copiez les exemples de formulaires W2 dans ce bucket :

export PROJECT_ID="$(gcloud config get-value core/project)" export BUCKET="${PROJECT_ID}"_doc_ai_async gsutil mb gs://${BUCKET} gsutil -m cp {{{project_0.startup_script.async_files_path|async_files_path}}} gs://${BUCKET}/input

3. Dans l'interface du notebook, ouvrez le notebook JupyterLab nommé .

4. Dans la boîte de dialogue Select Kernel (Sélectionner le kernel), sélectionnez Python 3 dans la liste des kernels disponibles.

Vérifier que l'instance Vertex AI a bien été préparée pour effectuer des appels asynchrones vers l'API Document AI

Tâche 7 : Envoyer une requête de traitement de document asynchrone

Vérifier le code Python pour les appels asynchrones vers l'API Document AI

Prenez quelques instants pour passer en revue le code Python dans le notebook .

La première cellule de code importe les bibliothèques nécessaires.

from google.cloud import documentai_v1beta3 as documentai from google.cloud import storage import re import os import pandas as pd import simplejson as json

La cellule de code Set your Processor ID précise l'identifiant de processeur que vous avez défini manuellement avant que vous puissiez traiter des documents avec le notebook.

processor_id = "PROCESSOR_ID" # TODO: Replace with a valid Processor ID

La cellule de code Set your variables définit les paramètres qui serviront à effectuer l'appel asynchrone, comme l'emplacement des buckets Cloud Storage d'entrée et de sortie qui seront utilisés pour les données sources et les fichiers de sortie. Vous modifierez les valeurs d'espace réservé PROJECT_ID et PROCESSOR_ID de cette cellule dans la prochaine section de cet atelier avant d'exécuter le code. Les autres variables contiennent les valeurs par défaut pour l'emplacement du processeur, le bucket Cloud Storage d'entrée et celui de sortie. Vous n'avez pas besoin de les modifier.

project_id = %system gcloud config get-value core/project project_id = project_id[0] location = 'us' # Replace with 'eu' if processor does not use 'us' location gcs_input_bucket = project_id+"_doc_ai_async" # Bucket name only, no gs:// prefix gcs_input_prefix = "input/" # Input bucket folder e.g. input/ gcs_output_bucket = project_id+"_doc_ai_async" # Bucket name only, no gs:// prefix gcs_output_prefix = "output/" # Input bucket folder e.g. output/ timeout = 300

La cellule de code Define Google Cloud client objects initialise les clients Document AI et Cloud Storage.

client_options = {"api_endpoint": "{}-documentai.googleapis.com".format(location)} client = documentai.DocumentProcessorServiceClient(client_options=client_options) storage_client = storage.Client()

La cellule de code Create input configuration crée le paramètre de tableau de la configuration d'entrée pour les données sources qui seront transmises comme configuration d'entrée à la requête Document AI asynchrone. Ce tableau stocke l'emplacement de la source Cloud Storage et le type MIME de chaque fichier se trouvant à l'emplacement Cloud Storage d'entrée.

blobs = storage_client.list_blobs(gcs_input_bucket, prefix=gcs_input_prefix) input_configs = [] print("Input Files:") for blob in blobs: if ".pdf" in blob.name: source = "gs://{bucket}/{name}".format(bucket = gcs_input_bucket, name = blob.name) print(source) input_config = documentai.types.document_processor_service.BatchProcessRequest.BatchInputConfig( gcs_source=source, mime_type="application/pdf" ) input_configs.append(input_config)

La cellule de code Create output configuration crée le paramètre de sortie de la requête asynchrone contenant l'emplacement du bucket Cloud Storage de sortie. Cette cellule le stocke sous la forme d'une configuration de sortie par lot Document AI.

destination_uri = f"gs://{gcs_output_bucket}/{gcs_output_prefix}" output_config = documentai.types.document_processor_service.BatchProcessRequest.BatchOutputConfig( gcs_destination=destination_uri )

La cellule de code Create the Document AI API request crée l'objet "request" de traitement par lot asynchrone Document AI à l'aide des objets de configuration d'entrée et de sortie.

name = f"projects/{project_id}/locations/{location}/processors/{processor_id}" request = documentai.types.document_processor_service.BatchProcessRequest( name=name, input_configs=input_configs, output_config=output_config, )

La cellule de code Start the batch (asynchronous) API operation envoie une requête de traitement de document asynchrone en transmettant l'objet "request" à la méthode batch_process_documents(). Comme il s'agit d'un appel asynchrone, vous devez utiliser la méthode result() pour obliger le notebook à attendre la fin du job asynchrone en arrière-plan.

operation = client.batch_process_documents(request) # Wait for the operation to finish operation.result(timeout=timeout) print ("Batch process completed.")

La cellule Fetch list of output files énumère les objets se trouvant à l'emplacement du bucket de sortie défini dans la variable destination_uri.

La cellule Display detected text from asynchronous output JSON files charge chaque fichier JSON de sortie trouvé sous la forme d'un objet "document" Document AI. Les données textuelles que détecte le processeur d'OCR dans les documents s'affichent.

La cellule Display entity data affiche toutes les données des entités trouvées. Toutefois, les données des entités ne sont disponibles que pour les processeurs créés à l'aide d'un analyseur spécialisé. Les données des entités ne seront pas affichées avec l'analyseur général par OCR Document AI utilisé dans cette tâche.

Exécuter le code Python asynchrone pour Document AI

Utilisez l'exemple de code fourni dans le notebook JupyterLab pour traiter les documents de manière asynchrone à l'aide d'une requête de traitement par lot Document AI.

1. Dans la deuxième cellule de code, remplacez le texte de l'espace réservé PROCESSOR_ID par l'identifiant du processeur form-parser que vous avez créé précédemment.

2. Sélectionnez la première cellule, cliquez sur le menu Run (Exécuter), puis sur Run Selected Cell and All Below (Exécuter la cellule sélectionnée et les suivantes) pour exécuter tout le code du notebook.

3. Pendant que les cellules de code s'exécutent, vous pouvez parcourir le notebook pour examiner le code et les commentaires qui expliquent comment l'objet de requête asynchrone est créé et utilisé.

Le notebook attendra une minute ou deux que l'opération de traitement par lot asynchrone se termine au niveau de la cellule de code Start the batch (asynchronous) API operation. Bien que l'appel d'API de traitement par lot lui-même soit asynchrone, le notebook utilise la méthode result pour obliger le notebook à attendre la fin de l'appel asynchrone avant d'énumérer et d'afficher les données de sortie.

Si le job asynchrone prend plus de temps que prévu et dépasse le délai d'expiration, vous devrez peut-être réexécuter les cellules restantes pour que le résultat s'affiche. Cela concernera les cellules après la cellule Start the batch (asynchronous) API operation.

La sortie contient du texte listant les données Document AI détectées dans chaque fichier. L'analyseur par OCR dans les documents ne détecte pas les formulaires ni les données des entités. Par conséquent, aucun formulaire ni données d'entités ne seront produits. Si vous parvenez à créer un processeur spécialisé, vous constaterez que la dernière cellule affiche les données des entités.

4. Dans le menu JupyterLab, cliquez sur File (Fichier), puis sur Save Notebook (Enregistrer le notebook) pour enregistrer votre progression.

Document processing complete. Text: FakeDoc M.D. HEALTH INTAKE FORM Please fill out the questionnaire carefully. The information you provide will be used to complete your health profile and will be kept confidential. Date: Sally Walker Name: 9/14/19 ... Vérifier qu'un document a bien été traité à l'aide de l'API Cloud Document asynchrone

Félicitations

Vous avez réussi à effectuer des appels synchrones et asynchrones vers l'API Document AI. Dans cet atelier, vous avez activé l'API Document AI et créé des processeurs. Vous avez installé la bibliothèque cliente pour Python dans une instance Vertex AI Workbench et analysé les données d'un formulaire scanné pour effectuer un appel d'API synchrone en Python. Vous avez également analysé les données de plusieurs formulaires scannés pour effectuer un appel d'API asynchrone avec ce même langage de programmation.

Terminer votre quête

Cet atelier d'auto-formation fait partie de la quête "Detect Manufacturing Defects using Visual Inspection AI", qui ouvre droit à un badge de compétence. Une quête est une série d'ateliers associés qui constituent un parcours de formation. Si vous terminez cette quête, vous obtenez un badge attestant de votre réussite. Ajoutez votre badge à votre CV et partagez-le sur les réseaux sociaux en utilisant le hashtag #GoogleCloudBadge. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à une quête pour obtenir immédiatement les crédits associés à cet atelier si vous l'avez suivi. Découvrez les autres quêtes disponibles.

Étapes suivantes et informations supplémentaires

• Pour en savoir plus sur l'utilisation des API Document AI, consultez ce guide.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 8 octobre 2024

Dernier test de l'atelier : 8 octobre 2024

Copyright 2024 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.