Cette page a été traduite par l'API Cloud Translation.

Déployer automatiquement l'application Web IA générative Go depuis le contrôle des versions vers Cloud Run

1. Présentation

Déployer une application Web pour la première fois peut sembler intimidant. Même après le premier déploiement, si le processus est trop lourd, vous pouvez éviter de déployer de nouvelles versions de votre application. Avec le déploiement continu, vous pouvez facilement déployer automatiquement les modifications de votre application.

Dans cet atelier, vous allez écrire une application Web et configurer Cloud Run pour déployer automatiquement votre application lorsqu'une modification est apportée au code source de votre application. Vous modifiez ensuite votre application et la déployez à nouveau.

Objectifs de l'atelier

Écrire une application Web avec l'éditeur Cloud Shell
Stocker le code de votre application dans GitHub
Déployer automatiquement votre application dans Cloud Run

Ajouter l'IA générative à votre application à l'aide de Vertex AI

2. Prérequis

Si vous ne possédez pas encore de compte Google, vous devez en créer un.
- Vous utilisez un compte personnel et non un compte professionnel ou scolaire. Les comptes professionnels et scolaires peuvent être soumis à des restrictions qui vous empêchent d'activer les API nécessaires à cet atelier.
Si vous ne possédez pas encore de compte GitHub, vous devez en créer un
- Utilisez un compte GitHub existant, le cas échéant. GitHub est plus susceptible de bloquer un nouveau compte en tant que spam.
- Configurez l'authentification à deux facteurs sur votre compte GitHub pour réduire les risques que votre compte soit marqué comme spam.

3. Configuration du projet

Connectez-vous à la console Google Cloud.
Activez la facturation dans la console Cloud.
- La réalisation de cet atelier devrait coûter moins de 1 USD en ressources Cloud.
- Vous pouvez suivre les étapes à la fin de cet atelier pour supprimer des ressources afin d'éviter que des frais supplémentaires ne vous soient facturés.
- Les nouveaux utilisateurs peuvent bénéficier d'un essai sans frais pour bénéficier d'un crédit de 300$.
- Vous participez à un événement sur l'IA générative pour les développeurs ? Un crédit de 1$ peut être disponible.
Créez un projet ou choisissez de réutiliser un projet existant.

4. Ouvrir l'éditeur Cloud Shell

Accédez à l'éditeur Cloud Shell.
Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le:
- Cliquez sur le menu hamburger .
- Cliquez sur Terminal
- Cliquez sur Nouveau terminal
Dans le terminal, définissez votre projet à l'aide de la commande suivante:
- Format :
```
gcloud config set project [PROJECT_ID]
```
- Exemple :
```
gcloud config set project lab-project-id-example
```
- Si vous ne vous souvenez pas de l'ID de votre projet:
  - Vous pouvez lister tous vos ID de projet avec:
```
gcloud projects list | awk '/PROJECT_ID/{print $2}'
```
Si vous y êtes invité, cliquez sur Autoriser pour continuer.
Le message suivant doit s'afficher :
```
Updated property [core/project].
```
Si un WARNING s'affiche et que vous êtes invité à saisir Do you want to continue (Y/N)?, vous avez probablement saisi l'ID de projet de manière incorrecte. Appuyez sur N, puis sur Enter, puis réessayez d'exécuter la commande gcloud config set project.

5. Activer les API

Dans le terminal, activez les API:

gcloud services enable \
  run.googleapis.com \
  cloudbuild.googleapis.com \
  aiplatform.googleapis.com

L'exécution de cette commande peut prendre quelques minutes, mais un message semblable à celui-ci devrait s'afficher pour vous indiquer que l'opération s'est correctement déroulée:

Operation "operations/acf.p2-73d90d00-47ee-447a-b600" finished successfully.

6. Configurer Git

Définissez votre adresse e-mail utilisateur Git globale:
```
git config --global user.email "you@example.com"
```

Définissez votre nom d'utilisateur Git global:

git config --global user.name "Your Name"

Définissez votre branche git globale par défaut sur main:
```
git config --global init.defaultBranch main
```

7. Rédiger le code

Pour écrire une application Go, procédez comme suit :

Accédez au répertoire d'accueil:
```
cd ~
```
Créez le répertoire codelab-genai:
```
mkdir codelab-genai
```
Accédez au répertoire codelab-genai :
```
cd codelab-genai
```
Initialisez un fichier go.mod pour déclarer notre module:
```
go mod init codelab-genai
```
Créez un fichier main.go :
```
touch main.go
```
Ouvrez le fichier main.go dans l'éditeur Cloud Shell:
```
cloudshell edit main.go
```
Un fichier vide devrait maintenant s'afficher en haut de l'écran. C'est là que vous pouvez modifier ce fichier main.go.

Modifiez main.go et collez-y le code suivant:

package main

import (
    "fmt"
    "log"
    "net/http"
    "os"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "Hello, world!")
    })

    port := os.Getenv("PORT")

    if port == "" {
        port = "8080"
    }
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        log.Fatal(err)
    }
}

Au bout de quelques secondes, l'éditeur Cloud Shell enregistre automatiquement votre code. Ce code répond aux requêtes HTTP avec notre message d'accueil "Hello world!".

Le code initial de votre application est terminé et prêt à être stocké dans un système de contrôle des versions.

8. Créer un dépôt

Revenez au terminal Cloud Shell en bas de l'écran.
Vérifiez que vous êtes toujours dans le bon répertoire:
```
cd ~/codelab-genai
```
Initialiser votre dépôt Git
```
git init -b main
```
Se connecter à la GitHub CLI
```
gh auth login
```
Appuyez sur Enter pour accepter les options par défaut et suivez les instructions de l'outil CLI GitHub, y compris les suivantes:
1. À quel compte souhaitez-vous vous connecter ? GitHub.com
2. Quel protocole préférez-vous pour les opérations Git sur cet hôte ? HTTPS
3. Authentifier Git avec vos identifiants GitHub ? Y (ignorez cette étape si elle ne s'affiche pas).
4. Comment souhaitez-vous authentifier la CLI GitHub ? Login with a web browser
5. Copiez votre code à usage unique
6. Ouvrez https://github.com/login/device.
7. Coller votre code unique
8. Cliquez sur Autoriser GitHub.
9. Connectez-vous
Vérifiez que vous êtes connecté:
```
gh api user -q ".login"
```
Si vous êtes bien connecté, votre nom d'utilisateur GitHub devrait s'afficher.

Créer une variable GITHUB_USERNAME

GITHUB_USERNAME=$(gh api user -q ".login")

Vérifiez que vous avez créé la variable d'environnement:
```
echo ${GITHUB_USERNAME}
```
Si vous avez correctement créé la variable, votre nom d'utilisateur GitHub devrait s'afficher.
Créez un dépôt GitHub vide nommé codelab-genai:
```
gh repo create codelab-genai --private
```
Si vous recevez l'erreur suivante:
```
GraphQL: Name already exists on this account (createRepository)
```
Vous disposez donc déjà d'un dépôt nommé codelab-genai. Pour continuer à suivre ce tutoriel, vous avez deux options:
- Supprimer le dépôt GitHub existant
- Créez un dépôt avec un autre nom et n'oubliez pas de le modifier dans les commandes suivantes.

Ajoutez le dépôt codelab-genai en tant que origin distant:

git remote add origin https://github.com/${GITHUB_USERNAME}/codelab-genai

9. Partager votre code

Vérifiez que vous êtes dans le bon répertoire:
```
cd ~/codelab-genai
```
Ajoutez tous les fichiers du répertoire actuel à ce commit:
```
git add .
```
Créez le premier commit:
```
git commit -m "add http server"
```
Transférez votre commit vers la branche main du dépôt origin:
```
git push -u origin main
```

Vous pouvez exécuter cette commande et accéder à l'URL générée pour afficher le code de votre application sur GitHub:

echo -e "\n\nTo see your code, visit this URL:\n \
    https://github.com/${GITHUB_USERNAME}/codelab-genai/blob/main/main.go \n\n"

10. Configurer des déploiements automatiques

Laissez l'onglet de l'éditeur Cloud Shell ouvert. Nous y reviendrons plus tard.
Dans un nouvel onglet, accédez à la page Cloud Run.
Sélectionnez le projet Google Cloud approprié dans la console .
Cliquez sur ASSOCIER UN REPO.
Cliquez sur CONFIGURER AVEC CLOUD BUILD
1. Sélectionnez GitHub comme fournisseur de dépôt.
  - Si vous n'êtes pas connecté à votre compte GitHub dans le navigateur, connectez-vous avec vos identifiants.
2. Cliquez sur Authentifier, puis sur Continuer.
3. Après vous être connecté, un message s'affiche sur la page Cloud Run indiquant que l'application GitHub n'est installée sur aucun de vos dépôts.
4. Cliquez sur le bouton INSTALL GOOGLE CLOUD BUILD (INSTALLER GOOGLE CLOUD BUILD).
  - Sur la page "Installation Setup" (Configuration de l'installation), sélectionnez Only select repositories (Sélectionner uniquement les dépôts) et choisissez le dépôt codelab-genai que vous avez créé à l'aide de la CLI.
  - Cliquez sur Installer.
  - Remarque: Si vous avez de nombreux dépôts GitHub, le chargement peut prendre quelques minutes.
5. Sélectionnez your-user-name/codelab-genai comme dépôt
  - Si le dépôt n'est pas présent, cliquez sur le lien Gérer les dépôts connectés.
6. Laissez Branche sur ^main$.
7. Cliquez sur Go, Node.js, Python, Java, .NET Core, Ruby ou PHP via les buildpacks Google Cloud
  - Laissez les autres champs (Build context directory, Entrypoint et Function target) tels quels.
8. Cliquez sur Enregistrer.
Faites défiler la page vers le bas jusqu'à Authentification.
Cliquez sur Autoriser les appels non authentifiés.
Cliquez sur CRÉER.

Une fois la compilation terminée (ce qui prend plusieurs minutes), exécutez cette commande et accédez à l'URL générée pour afficher votre application en cours d'exécution:

echo -e "\n\nOnce the build finishes, visit your live application:\n \
    "$( \
        gcloud run services list | \
        grep codelab-genai | \
        awk '/URL/{print $2}' | \
        head -1 \
    )" \n\n"

11. Modifier votre code

Revenez au terminal Cloud Shell en bas de l'écran.
Vérifiez que vous êtes toujours dans le bon répertoire:
```
cd ~/codelab-genai
```
Rouvrir main.go dans l'éditeur Cloud Shell
```
cloudshell edit main.go
```

Installez le SDK Vertex AI pour Go:

go get cloud.google.com/go/vertexai/genai

Installez la bibliothèque de métadonnées pour Go afin d'obtenir l'ID de projet actuel:
```
go get cloud.google.com/go/compute/metadata
```

Remplacez le code dans votre fichier main.go par:

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"

    "cloud.google.com/go/compute/metadata"
    "cloud.google.com/go/vertexai/genai"
)

func main() {
    ctx := context.Background()
    var projectId string
    var err error
    projectId = os.Getenv("GOOGLE_CLOUD_PROJECT")
    if projectId == "" {
        projectId, err = metadata.ProjectIDWithContext(ctx)
        if err != nil {
            return
        }
    }
    var client *genai.Client
    client, err = genai.NewClient(ctx, projectId, "us-central1")
    if err != nil {
        return
    }
    defer client.Close()

    model := client.GenerativeModel("gemini-1.5-flash-001")

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        animal := r.URL.Query().Get("animal")
        if animal == "" {
            animal = "dog"
        }

        resp, err := model.GenerateContent(
            ctx,
            genai.Text(
                fmt.Sprintf("Give me 10 fun facts about %s. Return the results as HTML without markdown backticks.", animal)),
        )

        if err != nil {
            w.WriteHeader(http.StatusServiceUnavailable)
            return
        }

        if len(resp.Candidates) > 0 && len(resp.Candidates[0].Content.Parts) > 0 {
            htmlContent := resp.Candidates[0].Content.Parts[0]
            w.Header().Set("Content-Type", "text/html; charset=utf-8")
            fmt.Fprint(w, htmlContent)
        }
    })

    port := os.Getenv("PORT")

    if port == "" {
        port = "8080"
    }
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        log.Fatal(err)
    }
}

12. Redéployer

Vérifiez que vous êtes toujours dans le bon répertoire dans Cloud Shell:
```
cd ~/codelab-genai
```
Exécutez ces commandes pour valider une nouvelle version de votre application dans votre dépôt Git local:
```
git add .
git commit -m "add latest changes"
```
Transférez les modifications vers GitHub:
```
git push
```

Une fois la compilation terminée, exécutez cette commande et accédez à votre application déployée:

echo -e "\n\nOnce the build finishes, visit your live application:\n \
    "$( \
        gcloud run services list | \
        grep codelab-genai | \
        awk '/URL/{print $2}' | \
        head -1 \
    )" \n\n"

La compilation peut prendre plusieurs minutes avant que vos modifications ne soient appliquées.

Vous pouvez consulter l'historique de toutes les révisions sur https://console.cloud.google.com/run/detail/us-central1/codelab-genai/revisions.

13. (Facultatif) Auditer votre utilisation de Vertex AI

Comme pour les autres services Google Cloud, vous pouvez effectuer un audit des opérations Vertex AI. Les journaux d'audit vous aident à répondre aux questions suivantes : "Qui a fait quoi, où et quand ?". Les journaux d'audit d'administration pour Vertex AI sont activés par défaut. Pour auditer les requêtes de génération de contenu, vous devez activer les journaux d'audit des accès aux données:

Dans la console Google Cloud, accédez à la page Journaux d'audit:

Si vous utilisez la barre de recherche pour trouver cette page, sélectionnez le résultat dont le sous-titre est IAM et administration.
Assurez-vous que le projet Google Cloud existant est celui dans lequel vous créez votre application Cloud Run.
Dans le tableau Configuration des journaux d'audit des accès aux données, recherchez Vertex AI API dans la colonne "Service".
Dans l'onglet Types de journaux, sélectionnez les types de journaux d'audit pour l'accès aux données Admin read et Data read.
Cliquez sur Enregistrer.

Une fois l'activation effectuée, vous pourrez consulter les journaux d'audit pour chaque appel de l'application. Pour afficher les journaux d'audit avec les détails d'invocation, procédez comme suit:

Revenez à votre application déployée et actualisez la page pour déclencher le journal.
Dans la console Google Cloud, accédez à la page Explorateur de journaux:

Dans la fenêtre de requête, saisissez:

LOG_ID("cloudaudit.googleapis.com%2Fdata_access")
protoPayload.serviceName="aiplatform.googleapis.com"

Cliquez sur Exécuter la requête.

Les journaux d'audit enregistrent l'utilisation de l'API Vertex AI, mais ils ne vous permettent pas d'observer les données liées à la charge de travail, telles que les invites ou les détails de la réponse.

14. (Facultatif) Améliorer l'observabilité de votre charge de travail d'IA

Les journaux d'audit ne collectent pas d'informations sur la charge de travail. Pour améliorer l'observabilité de vos charges de travail, vous devez consigner explicitement ces informations. Pour ce faire, vous pouvez utiliser votre framework de journalisation préféré. Les étapes suivantes montrent comment procéder à l'aide de la bibliothèque de journalisation structurée de Go.

Rouvrir main.go dans l'éditeur Cloud Shell

cloudshell edit ~/codelab-genai/main.go

Modifiez votre bloc d'importation pour inclure la journalisation structurée et les bibliothèques JSON de Go:

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "log/slog"
    "net/http"
    "os"

    "cloud.google.com/go/compute/metadata"
    "cloud.google.com/go/vertexai/genai"
)

Après avoir initialisé votre client Vertex (ligne 33), ajoutez les lignes suivantes pour initialiser un enregistreur structuré qui utilise les champs appropriés pour Google Cloud Logging:

opts := &slog.HandlerOptions{
	Level: slog.LevelDebug,
	ReplaceAttr: func(group []string, a slog.Attr) slog.Attr {
        if a.Key == slog.LevelKey {
            return slog.Attr{Key: "severity", Value: a.Value}
        }
        if a.Key == slog.MessageKey {
            return slog.Attr{Key: "message", Value: a.Value}
        }
        return slog.Attr{Key: a.Key, Value: a.Value}
	},
}

jsonHandler := slog.NewJSONHandler(os.Stdout, opts)
slog.SetDefault(slog.New(jsonHandler))

Après avoir vérifié la réponse à GenerateContent (ligne 69), ajoutez les lignes suivantes dans le bloc "if" :
```
jsonBytes, err := json.Marshal(resp)
if err != nil {
    slog.Error("Failed to marshal response to JSON", "error", err)
} else {
    jsonString := string(jsonBytes)
    slog.Debug("Complete response content", "json_response", jsonString)
}
```
Ce code écrit dans stdout des informations sur le contenu généré à l'aide du format de journalisation structurée. Un agent de journalisation dans Cloud Run capture la sortie imprimée dans stdout et écrit ce format dans Cloud Logging.
Rouvrez Cloud Shell et saisissez la commande suivante pour vous assurer que vous êtes dans le bon répertoire:
```
cd ~/codelab-genai
```

Effectuez un commit sur les modifications :

git commit -am "Observe generated content"

Transférez les modifications sur GitHub pour déclencher le redéploiement de la version modifiée:
```
git push
```

Une fois la nouvelle version déployée, vous pouvez consulter les informations de débogage sur les appels à Vertex AI.

Pour afficher les journaux de votre application, procédez comme suit:

Dans la console Google Cloud, accédez à la page Explorateur de journaux:

Dans la fenêtre de requête, saisissez:

LOG_ID("run.googleapis.com%2Fstdout")
severity=DEBUG

Cliquez sur Exécuter la requête.

Le résultat de la requête affiche des journaux avec la requête et la réponse de Vertex AI, y compris des "notes de sécurité" qui peuvent être utilisées pour surveiller les pratiques de sécurité.

15. (Facultatif) Effectuer un nettoyage

Bien que Cloud Run ne facture pas lorsque le service n'est pas utilisé, il se peut que des frais vous soient facturés pour le stockage de l'image de conteneur dans Artifact Registry. Vous pouvez supprimer votre projet Cloud pour éviter des frais. La suppression de votre projet Cloud arrête la facturation de toutes les ressources utilisées dans ce projet.

Si vous le souhaitez, supprimez le projet:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

Vous pouvez également supprimer les ressources inutiles de votre disque cloudshell. Vous pouvez :

Supprimez le répertoire du projet de l'atelier de programmation:
```
rm -rf ~/codelab-genai
```
Nettoyez les packages Go dont vous n'avez peut-être plus besoin:
```
cd ~
go clean -modcache
```
Avertissement ! Cette action est irréversible. Si vous souhaitez supprimer tout ce qui se trouve sur votre Cloud Shell pour libérer de l'espace, vous pouvez supprimer l'intégralité de votre répertoire personnel. Assurez-vous que tout ce que vous souhaitez conserver est enregistré ailleurs.
```
sudo rm -rf $HOME
```

16. Félicitations

Dans cet atelier, vous avez écrit une application Web et configuré Cloud Run pour qu'il déploie automatiquement votre application lorsqu'une modification est apportée au code source de votre application. Vous avez ensuite modifié votre application et l'avez de nouveau déployée.

Si vous avez apprécié cet atelier, vous pouvez le refaire dans un autre langage de programmation ou framework:

Si vous souhaitez participer à une étude de recherche sur l'expérience utilisateur (UX) afin d'améliorer les produits que vous avez utilisés aujourd'hui, inscrivez-vous ici.

Voici quelques options pour poursuivre votre apprentissage:

Documentation: utilisez Firebase GenKit comme abstraction de modèle flexible qui facilite l'intégration de n'importe quelle API de modèle et l'utilisation de modèles gérés par la communauté.
Atelier de programmation: Déployer une application de chat basée sur Gemini sur Cloud Run
Utiliser l'appel de fonction Gemini avec Cloud Run
Atelier à la demande: Intégration de Google Kubernetes Engine
Utiliser l'API Video Intelligence pour Cloud Run Jobs afin de traiter une vidéo scène par scène