Guía de inicio rápido

Las guías de inicio rápido explican cómo configurar y ejecutar una app que llama a un API de Google Workspace.

Las guías de inicio rápido de Google Workspace usan las bibliotecas cliente de la API para controlar algunas los detalles del flujo de autenticación y autorización. Te recomendamos lo siguiente: usas las bibliotecas cliente para tus propias apps. En esta guía de inicio rápido, se usa un de autenticación simplificado, adecuado para realizar pruebas en un entorno de nube. Para un entorno de producción, recomendamos conocer autenticación y autorización antes de elige las credenciales de acceso que sean adecuados para tu app.

Crear una aplicación de línea de comandos de Go que realice solicitudes a la API de Google Drive Activity.

Objetivos

• Configurar el entorno
• Configura la muestra.
• Ejecuta la muestra.

Requisitos previos

• La versión más reciente de Go.
• La versión más reciente de Git.
• Un proyecto de Google Cloud.

• Una Cuenta de Google

Configura tu entorno

Para completar esta guía de inicio rápido, configura tu entorno.

Habilita la API

Antes de usar las APIs de Google, debes activarlas en un proyecto de Google Cloud. Puedes activar una o más APIs en un solo proyecto de Google Cloud.

• En la consola de Google Cloud, habilita la API de actividad de Google Drive.

  Habilitar la API

Cómo configurar la pantalla de consentimiento de OAuth

Si usas un proyecto de Google Cloud nuevo para completar esta guía de inicio rápido, configura la pantalla de consentimiento de OAuth y agrégate como usuario de prueba. Si ya has completaste este paso para tu proyecto de Cloud, ve a la siguiente sección.

1. En la consola de Google Cloud, ve a Menú > APIs y Servicios > Pantalla de consentimiento de OAuth.

   Ir a la pantalla de consentimiento de OAuth

2. En Tipo de usuario, selecciona Interno y, luego, haz clic en Crear.
3. Completa el formulario de registro de apps y, luego, haz clic en Guardar y continuar.

4. Por ahora, puedes omitir el paso de agregar permisos y hacer clic en Guardar y continuar. En el futuro, cuando crees una app para usarla fuera de tu organización de Google Workspace, debes cambiar el Tipo de usuario a Externo y, luego, agregar los permisos de autorización que requiere tu app.

5. Revisa el resumen del registro de tu app. Para realizar cambios, haz clic en Editar. Si la aplicación el registro parece estar bien, haz clic en Volver al panel.

Autoriza credenciales para una aplicación de escritorio

Para autenticar usuarios finales y acceder a sus datos en tu app, debes hacer lo siguiente: crear uno o más IDs de cliente de OAuth 2.0. Un ID de cliente se usa con el fin de identificar una sola app para los servidores de OAuth de Google. Si tu app se ejecuta en varias plataformas debes crear un ID de cliente diferente para cada plataforma.

1. En la consola de Google Cloud, ve a Menú > APIs y Servicios > Credenciales.

   Ir a Credenciales

2. Haz clic en Crear credenciales > ID de cliente de OAuth.
3. Haz clic en Tipo de aplicación > Aplicación para computadoras.
4. En el campo Nombre, escribe un nombre para la credencial. Este nombre solo se muestra en la consola de Google Cloud.
5. Haz clic en Crear. Aparecerá la pantalla de creación del cliente de OAuth, en la que se mostrará tu nuevo ID de cliente y secreto del cliente.
6. Haz clic en Aceptar. La credencial creada recientemente aparece en ID de cliente de OAuth 2.0.
7. Guarda el archivo JSON descargado como credentials.json y mueve el a tu directorio de trabajo.

Prepara el lugar de trabajo

1. Cree un directorio de trabajo:

   mkdir quickstart
   

2. Cambia al directorio de trabajo:

   cd quickstart
   

3. Inicializa el módulo nuevo:

   go mod init quickstart
   

4. Obtén la biblioteca cliente de Go de la API de Google Drive Activity y el paquete de OAuth2.0:

   go get google.golang.org/api/driveactivity/v2
   go get golang.org/x/oauth2/google
   

Configura la muestra

1. En el directorio de trabajo, crea un archivo llamado quickstart.go.

2. En el archivo, pega el siguiente código:

   drive/activity-v2/quickstart/quickstart.go

   Ver en GitHub

   package main
   
   import (
   	"context"
   	"encoding/json"
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   	"reflect"
   	"strings"
   
   	"golang.org/x/oauth2"
   	"golang.org/x/oauth2/google"
   	"google.golang.org/api/driveactivity/v2"
   	"google.golang.org/api/option"
   )
   
   // Retrieve a token, saves the token, then returns the generated client.
   func getClient(config *oauth2.Config) *http.Client {
   	// The file token.json stores the user's access and refresh tokens, and is
   	// created automatically when the authorization flow completes for the first
   	// time.
   	tokFile := "token.json"
   	tok, err := tokenFromFile(tokFile)
   	if err != nil {
   		tok = getTokenFromWeb(config)
   		saveToken(tokFile, tok)
   	}
   	return config.Client(context.Background(), tok)
   }
   
   // Request a token from the web, then returns the retrieved token.
   func getTokenFromWeb(config *oauth2.Config) *oauth2.Token {
   	authURL := config.AuthCodeURL("state-token", oauth2.AccessTypeOffline)
   	fmt.Printf("Go to the following link in your browser then type the "+
   		"authorization code: \n%v\n", authURL)
   
   	var authCode string
   	if _, err := fmt.Scan(&authCode); err != nil {
   		log.Fatalf("Unable to read authorization code: %v", err)
   	}
   
   	tok, err := config.Exchange(context.TODO(), authCode)
   	if err != nil {
   		log.Fatalf("Unable to retrieve token from web: %v", err)
   	}
   	return tok
   }
   
   // Retrieves a token from a local file.
   func tokenFromFile(file string) (*oauth2.Token, error) {
   	f, err := os.Open(file)
   	if err != nil {
   		return nil, err
   	}
   	defer f.Close()
   	tok := &oauth2.Token{}
   	err = json.NewDecoder(f).Decode(tok)
   	return tok, err
   }
   
   // Saves a token to a file path.
   func saveToken(path string, token *oauth2.Token) {
   	fmt.Printf("Saving credential file to: %s\n", path)
   	f, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
   	if err != nil {
   		log.Fatalf("Unable to cache oauth token: %v", err)
   	}
   	defer f.Close()
   	json.NewEncoder(f).Encode(token)
   }
   
   // Returns a string representation of the first elements in a list.
   func truncated(array []string) string {
   	return truncatedTo(array, 2)
   }
   
   // Returns a string representation of the first elements in a list.
   func truncatedTo(array []string, limit int) string {
   	var contents string
   	var more string
   	if len(array) <= limit {
   		contents = strings.Join(array, ", ")
   		more = ""
   	} else {
   		contents = strings.Join(array[0:limit], ", ")
   		more = ", ..."
   	}
   	return fmt.Sprintf("[%s%s]", contents, more)
   }
   
   // Returns the name of a set property in an object, or else "unknown".
   func getOneOf(m interface{}) string {
   	v := reflect.ValueOf(m)
   	for i := 0; i < v.NumField(); i++ {
   		if !v.Field(i).IsNil() {
   			return v.Type().Field(i).Name
   		}
   	}
   	return "unknown"
   }
   
   // Returns a time associated with an activity.
   func getTimeInfo(activity *driveactivity.DriveActivity) string {
   	if activity.Timestamp != "" {
   		return activity.Timestamp
   	}
   	if activity.TimeRange != nil {
   		return activity.TimeRange.EndTime
   	}
   	return "unknown"
   }
   
   // Returns the type of action.
   func getActionInfo(action *driveactivity.ActionDetail) string {
   	return getOneOf(*action)
   }
   
   // Returns user information, or the type of user if not a known user.
   func getUserInfo(user *driveactivity.User) string {
   	if user.KnownUser != nil {
   		if user.KnownUser.IsCurrentUser {
   			return "people/me"
   		}
   		return user.KnownUser.PersonName
   	}
   	return getOneOf(*user)
   }
   
   // Returns actor information, or the type of actor if not a user.
   func getActorInfo(actor *driveactivity.Actor) string {
   	if actor.User != nil {
   		return getUserInfo(actor.User)
   	}
   	return getOneOf(*actor)
   }
   
   // Returns information for a list of actors.
   func getActorsInfo(actors []*driveactivity.Actor) []string {
   	actorsInfo := make([]string, len(actors))
   	for i := range actors {
   		actorsInfo[i] = getActorInfo(actors[i])
   	}
   	return actorsInfo
   }
   
   // Returns the type of a target and an associated title.
   func getTargetInfo(target *driveactivity.Target) string {
   	if target.DriveItem != nil {
   		return fmt.Sprintf("driveItem:\"%s\"", target.DriveItem.Title)
   	}
   	if target.Drive != nil {
   		return fmt.Sprintf("drive:\"%s\"", target.Drive.Title)
   	}
   	if target.FileComment != nil {
   		parent := target.FileComment.Parent
   		if parent != nil {
   			return fmt.Sprintf("fileComment:\"%s\"", parent.Title)
   		}
   		return "fileComment:unknown"
   	}
   	return getOneOf(*target)
   }
   
   // Returns information for a list of targets.
   func getTargetsInfo(targets []*driveactivity.Target) []string {
   	targetsInfo := make([]string, len(targets))
   	for i := range targets {
   		targetsInfo[i] = getTargetInfo(targets[i])
   	}
   	return targetsInfo
   }
   
   func main() {
   	ctx := context.Background()
   	b, err := os.ReadFile("credentials.json")
   	if err != nil {
   		log.Fatalf("Unable to read client secret file: %v", err)
   	}
   
   	// If modifying these scopes, delete your previously saved token.json.
   	config, err := google.ConfigFromJSON(b, driveactivity.DriveActivityReadonlyScope)
   	if err != nil {
   		log.Fatalf("Unable to parse client secret file to config: %v", err)
   	}
   	client := getClient(config)
   
   	srv, err := driveactivity.NewService(ctx, option.WithHTTPClient(client))
   	if err != nil {
   		log.Fatalf("Unable to retrieve driveactivity Client %v", err)
   	}
   
   	q := driveactivity.QueryDriveActivityRequest{PageSize: 10}
   	r, err := srv.Activity.Query(&q).Do()
   	if err != nil {
   		log.Fatalf("Unable to retrieve list of activities. %v", err)
   	}
   
   	fmt.Println("Recent Activity:")
   	if len(r.Activities) > 0 {
   		for _, a := range r.Activities {
   			time := getTimeInfo(a)
   			action := getActionInfo(a.PrimaryActionDetail)
   			actors := getActorsInfo(a.Actors)
   			targets := getTargetsInfo(a.Targets)
   			fmt.Printf("%s: %s, %s, %s\n", time, truncated(actors), action, truncated(targets))
   		}
   	} else {
   		fmt.Print("No activity.")
   	}
   }
   

Ejecuta la muestra

1. En tu directorio de trabajo, compila y ejecuta la muestra:

   go run quickstart.go
   

2. La primera vez que ejecutes la muestra, se te solicitará que autorices el acceso:
   1. Si aún no accediste a tu Cuenta de Google, hazlo cuando se te solicite. Si accediste a varias cuentas, selecciona una para usar la autorización.
   2. Haz clic en Aceptar.

   Tu aplicación de Go se ejecuta y llama a la API de actividad de Google Drive.

   La información de autorización se almacena en el sistema de archivos; por lo tanto, la próxima vez que ejecutes la muestra código, no se te solicitará autorización.

Próximos pasos

• Soluciona problemas de autenticación y autorización
• Documentación de referencia de la API de Drive Activity
• Sección google-api-go-client de GitHub