Se usó la API de Cloud Translation para traducir esta página.

Implementa automáticamente la aplicación web de Go con IA generativa desde el control de versiones hasta Cloud Run

1. Descripción general

Implementar una aplicación web por primera vez puede ser intimidante. Incluso después de la primera implementación, si el proceso requiere demasiado trabajo, es posible que evites implementar versiones nuevas de tu aplicación. Con la implementación continua, puedes implementar los cambios de tu aplicación de forma automática y sencilla.

En este lab, escribirás una aplicación web y configurarás Cloud Run para que implemente automáticamente tu aplicación cuando se realice un cambio en el código fuente de la aplicación. Luego, modificas la aplicación y la vuelves a implementar.

Qué aprenderás

Cómo escribir una aplicación web con el editor de Cloud Shell
Almacena el código de tu aplicación en GitHub
Implementa tu aplicación en Cloud Run de forma automática

Agrega IA generativa a tu aplicación con Vertex AI

2. Requisitos previos

Si aún no tienes una Cuenta de Google, debes crear una.
- Usa una cuenta personal en lugar de una cuenta de trabajo o de institución educativa. Es posible que las cuentas de trabajo o de instituciones educativas tengan restricciones que te impidan habilitar las APIs necesarias para este lab.
Si aún no tienes una cuenta de GitHub, debes crear una
- Usa una cuenta de GitHub existente si tienes una. Es más probable que GitHub bloquee una cuenta nueva como spam.
- Configura la autenticación de dos factores en tu cuenta de GitHub para reducir las probabilidades de que se marque como spam.

3. Configura el proyecto

Accede a la consola de Google Cloud.
Habilita la facturación en la consola de Cloud.
- Completar este lab debería costar menos de USD 1 en recursos de Cloud.
- Puedes seguir los pasos que se indican al final de este lab para borrar recursos y evitar cargos adicionales.
- Los usuarios nuevos son aptos para la prueba gratuita de USD 300.
- ¿Asisterás a un evento de IA generativa para desarrolladores? Es posible que haya un crédito de USD 1 disponible.
Crea un proyecto nuevo o elige reutilizar uno existente.

4. Abrir el editor de Cloud Shell

Navega al Editor de Cloud Shell.
Si la terminal no aparece en la parte inferior de la pantalla, ábrela:
- Haz clic en el menú de opciones .
- Haz clic en Terminal.
- Haz clic en Terminal nueva.
En la terminal, configura tu proyecto con este comando:
- Formato:
```
gcloud config set project [PROJECT_ID]
```
- Ejemplo:
```
gcloud config set project lab-project-id-example
```
- Si no recuerdas el ID de tu proyecto, haz lo siguiente:
  - Puedes enumerar todos los IDs de tus proyectos con lo siguiente:
```
gcloud projects list | awk '/PROJECT_ID/{print $2}'
```
Si se te solicita autorización, haz clic en Autorizar para continuar.
Deberías ver el siguiente mensaje:
```
Updated property [core/project].
```
Si ves un WARNING y se te pregunta Do you want to continue (Y/N)?, es probable que hayas ingresado el ID del proyecto de forma incorrecta. Presiona N, presiona Enter y vuelve a intentar ejecutar el comando gcloud config set project.

5. Habilita las APIs

En la terminal, habilita las APIs:

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

Este comando puede tardar unos minutos en completarse, pero, en algún momento, debería mostrar un mensaje de éxito similar al siguiente:

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

6. Configurar Git

Establece tu correo electrónico de usuario global de git:
```
git config --global user.email "you@example.com"
```
Establece tu nombre de usuario global de git:
```
git config --global user.name "Your Name"
```
Establece la rama predeterminada de git global en main:
```
git config --global init.defaultBranch main
```

7. Escribe el código

Para escribir una aplicación en Go, sigue estos pasos:

Navega al directorio principal:
```
cd ~
```
Crea el directorio codelab-genai:
```
mkdir codelab-genai
```
Navega al directorio codelab-genai:
```
cd codelab-genai
```
Inicializa un archivo go.mod para declarar nuestro módulo:
```
go mod init codelab-genai
```
Crea un archivo main.go:
```
touch main.go
```
Abre el archivo main.go en el editor de Cloud Shell:
```
cloudshell edit main.go
```
Ahora debería aparecer un archivo vacío en la parte superior de la pantalla. Aquí es donde puedes editar el archivo main.go.

Edita main.go y pega el siguiente código:

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)
    }
}

Después de unos segundos, el editor de Cloud Shell guardará tu código automáticamente. Este código responde a las solicitudes HTTP con nuestro saludo “Hello world!”.

El código inicial de tu aplicación está terminado y listo para almacenarse en el control de versión.

8. Crea un repositorio

Regresa a la terminal de Cloud Shell en la parte inferior de la pantalla.
Asegúrate de estar en el directorio correcto:
```
cd ~/codelab-genai
```
Inicializa tu repositorio de git
```
git init -b main
```
Accede a GitHub CLI
```
gh auth login
```
Presiona Enter para aceptar las opciones predeterminadas y sigue las instrucciones de la herramienta de GitHub CLI, incluidas las siguientes:
1. ¿A qué cuenta quieres acceder? GitHub.com
2. ¿Cuál es tu protocolo preferido para las operaciones de Git en este host? HTTPS
3. ¿Quieres autenticar Git con tus credenciales de GitHub? Y (omite este paso si no aparece).
4. ¿Cómo te gustaría autenticar GitHub CLI? Login with a web browser
5. Copia tu código de un solo uso
6. Abre https://github.com/login/device.
7. Pega el código de uso único
8. Haz clic en Autorizar GitHub.
9. Completa el acceso
Confirma que accediste:
```
gh api user -q ".login"
```
Si accediste correctamente, se debería mostrar tu nombre de usuario de GitHub.

Crea una variable GITHUB_USERNAME

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

Confirma que creaste la variable de entorno:
```
echo ${GITHUB_USERNAME}
```
Si creaste la variable correctamente, se debería mostrar tu nombre de usuario de GitHub.
Crea un repositorio de GitHub vacío llamado codelab-genai:
```
gh repo create codelab-genai --private
```
Si recibes el error:
```
GraphQL: Name already exists on this account (createRepository)
```
Significa que ya tienes un repositorio llamado codelab-genai. Tienes dos opciones para seguir con este instructivo:
- Borra el repositorio de GitHub existente
- Crea un repositorio con un nombre diferente y recuerda cambiarlo en los siguientes comandos.

Agrega el repositorio codelab-genai como el origin remoto:

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

9. Comparte tu código

Confirma que estás en el directorio correcto:
```
cd ~/codelab-genai
```
Agrega todos los archivos del directorio actual a esta confirmación:
```
git add .
```
Crea la primera confirmación:
```
git commit -m "add http server"
```
Envía tu confirmación a la rama main del repositorio origin:
```
git push -u origin main
```

Puedes ejecutar este comando y visitar la URL resultante para ver el código de tu aplicación en 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. Configura implementaciones automáticas

Deja abierta la pestaña del editor de Cloud Shell. Volveremos a esta pestaña más adelante.
En una pestaña nueva, visita la página de Cloud Run.
Selecciona el proyecto de Google Cloud correcto en la consola
Haz clic en CONNECT REPO.
Haz clic en CONFIGURAR CON CLOUD BUILD
1. Selecciona GitHub como el Proveedor de repositorio
  - Si no accediste a tu cuenta de GitHub en el navegador, accede con tus credenciales.
2. Haz clic en Autenticar y, luego, en Continuar.
3. Después de acceder, verás un mensaje en la página de Cloud Run que indica que la app de GitHub no está instalada en ninguno de tus repositorios.
4. Haz clic en el botón INSTALL GOOGLE CLOUD BUILD.
  - En la página Configuración de instalación, selecciona Solo repositorios seleccionados y elige el repositorio codelab-genai que creaste a través de la CLI.
  - Haz clic en Install.
  - Nota: Si tienes muchos repositorios de GitHub, la carga puede tardar unos minutos.
5. Selecciona your-user-name/codelab-genai como el repositorio
  - Si el repositorio no está presente, haz clic en el vínculo Administrar repositorios conectados.
6. Deja Rama como ^main$.
7. Haz clic en Go, Node.js, Python, Java, .NET Core, Ruby o PHP a través de los paquetes de compilación de Google Cloud
  - Deja los otros campos (Build context directory, Entrypoint y Function target) como están.
8. Haga clic en Guardar.
Desplázate hacia abajo hasta Authentication.
Haz clic en Permitir invocaciones no autenticadas.
Haz clic en CREAR.

Una vez que finalice la compilación (lo que llevará varios minutos), ejecuta este comando y visita la URL resultante para ver la aplicación en ejecución:

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. Cambia tu código

Regresa a la terminal de Cloud Shell en la parte inferior de la pantalla.
Asegúrate de estar en el directorio correcto:
```
cd ~/codelab-genai
```
Vuelve a abrir main.go en el editor de Cloud Shell
```
cloudshell edit main.go
```

Instala el SDK de Vertex AI para Go:

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

Instala la biblioteca de metadatos para Go para obtener el ID del proyecto actual:
```
go get cloud.google.com/go/compute/metadata
```

Reemplaza el código de tu archivo main.go por lo siguiente:

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. Volver a implementar

Asegúrate de que aún te encuentras en el directorio correcto en Cloud Shell:
```
cd ~/codelab-genai
```
Ejecuta estos comandos para confirmar una versión nueva de tu aplicación en tu repositorio de git local:
```
git add .
git commit -m "add latest changes"
```
Envía los cambios a GitHub:
```
git push
```

Una vez que se complete la compilación, ejecuta este comando y visita la aplicación implementada:

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 compilación puede tardar varios minutos en completarse antes de que puedas ver los cambios.

Puedes ver el historial de todas las revisiones aquí: https://console.cloud.google.com/run/detail/us-central1/codelab-genai/revisions

13. (Opcional) Audita tu uso de Vertex AI

Al igual que con otros servicios de Google Cloud, puedes auditar las operaciones de Vertex AI. Los registros de auditoría te ayudan a responder las preguntas “¿Quién hizo qué, dónde y cuándo?”. Los registros de auditoría administrativa de Vertex AI están habilitados de forma predeterminada. Para auditar las solicitudes de generación de contenido, debes habilitar los registros de auditoría de acceso a los datos:

En la consola de Google Cloud, ve a la página Registros de auditoría:

Si usas la barra de búsqueda para encontrar esta página, selecciona el resultado cuyo subtítulo es IAM y administración.
Asegúrate de que el proyecto de Google Cloud existente sea el en el que crees tu aplicación de Cloud Run.
En la tabla Configuración de los registros de auditoría de acceso a los datos, busca y selecciona Vertex AI API en la columna Servicio.
En la pestaña Tipos de registro, selecciona los tipos de registros de auditoría de acceso a los datos Admin read y Data read.
Haz clic en Guardar.

Después de habilitarlo, podrás ver los registros de auditoría de cada invocación de la aplicación. Para ver los registros de auditoría con los detalles de la invocación, haz lo siguiente:

Regresa a la aplicación implementada y actualiza la página para activar el registro.
En la consola de Google Cloud, ve a la página Explorador de registros:

En la ventana de consulta, escribe:

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

Haz clic en Ejecutar consulta.

Los registros de auditoría capturan el uso de la API de Vertex AI, pero no te permiten observar datos relacionados con la carga de trabajo, como instrucciones o detalles de respuestas.

14. Aumenta la observabilidad de tu carga de trabajo de IA (opcional)

Los registros de auditoría no capturan información relacionada con la carga de trabajo. Para aumentar la visibilidad de tus cargas de trabajo, debes registrar esta información de forma explícita. Para ello, puedes usar tu framework de registro favorito. En los siguientes pasos, se muestra una forma de hacerlo con la biblioteca de registro estructurado de Go.

Vuelve a abrir main.go en el editor de Cloud Shell
```
cloudshell edit ~/codelab-genai/main.go
```

Cambia tu bloque de importación para incluir las bibliotecas de registro estructurado y 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"
)

Después de inicializar tu cliente de Vertex (línea 33), agrega las siguientes líneas para inicializar un registrador estructurado que use los campos correctos para 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))

Después de verificar si hay una respuesta a GenerateContent (línea 69), agrega las siguientes líneas dentro del bloque 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)
}
```
Este código escribe en stdout información sobre el contenido generado con el formato de registro estructurado. Un agente de registro en Cloud Run captura el resultado impreso en stdout y escribe este formato en Cloud Logging.
Vuelve a abrir Cloud Shell y escribe el siguiente comando para asegurarte de que estás en el directorio correcto:
```
cd ~/codelab-genai
```

Confirma los cambios:

git commit -am "Observe generated content"

Envía los cambios a GitHub para activar la nueva implementación de la versión modificada:
```
git push
```

Después de que se implemente la versión nueva, puedes observar la información de depuración sobre las llamadas a Vertex AI.

Para ver los registros de tu aplicación, haz lo siguiente:

En la consola de Google Cloud, ve a la página Explorador de registros:

En la ventana de consulta, escribe:

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

Haz clic en Ejecutar consulta.

El resultado de la consulta muestra registros con la instrucción y la respuesta de Vertex AI, incluidas las "calificaciones de seguridad" que se pueden usar para supervisar las prácticas de seguridad.

15. (Opcional) Limpieza

Si bien Cloud Run no cobra cuando el servicio no se usa, es posible que se te cobre por el almacenamiento de la imagen del contenedor en Artifact Registry. Puedes borrar tu proyecto de Cloud para evitar que se generen cargos. Si borras tu proyecto de Cloud, se detendrá la facturación de todos los recursos que usaste en ese proyecto.

Si lo deseas, borra el proyecto:

gcloud projects delete $GOOGLE_CLOUD_PROJECT

También te recomendamos que borres los recursos innecesarios del disco de CloudShell. Puedes hacer lo siguiente:

Borra el directorio del proyecto del codelab:
```
rm -rf ~/codelab-genai
```
Limpia los paquetes de Go que ya no necesites:
```
cd ~
go clean -modcache
```
Advertencia. No se puede deshacer esta acción. Si quieres borrar todo en Cloud Shell para liberar espacio, puedes borrar todo el directorio principal. Asegúrate de que todo lo que quieras conservar esté guardado en otro lugar.
```
sudo rm -rf $HOME
```

16. Felicitaciones

En este lab, escribiste una aplicación web y configuraste Cloud Run para implementarla automáticamente cuando se realizara un cambio en el código fuente de la aplicación. Luego, modificaste la aplicación y la volviste a implementar.

Si disfrutaste este lab, puedes volver a intentarlo en otro lenguaje de programación o framework:

Si te interesa participar en un estudio de investigación de experiencia del usuario (UX) para mejorar los productos con los que trabajaste hoy, regístrate aquí.

Estas son algunas opciones para continuar con tu aprendizaje:

Documentos: Usa Firebase GenKit como una abstracción de modelo flexible que facilita la integración de cualquier API de modelo y el uso de modelos mantenidos por la comunidad.
Codelab: Cómo implementar una app de chat potenciada por Gemini en Cloud Run
Cómo usar las llamadas a funciones de Gemini con Cloud Run
Taller on demand: Integración de Google Kubernetes Engine
Cómo usar la API de Video Intelligence de Cloud Run Jobs para procesar un video por escena