Guía de inicio rápido

Crea una aplicación de línea de comandos de Go que realice solicitudes a la API de Google Calendar.

En las guías de inicio rápido, se explica cómo configurar y ejecutar una app que llama a una API de Google Workspace. En esta guía de inicio rápido, se usa un enfoque de autenticación simplificado que es adecuado para un entorno de pruebas. Para un entorno de producción, te recomendamos que obtengas información sobre la autenticación y la autorización antes de elegir las credenciales de acceso que sean adecuadas para tu app.

En esta guía de inicio rápido, se usan las bibliotecas cliente de la API recomendadas de Google Workspace para controlar algunos detalles del flujo de autenticación y autorización.

Objetivos

• Configura 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 con Google Calendar habilitado

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 Google Calendar.

  Habilitar la API

Cómo configurar la pantalla de consentimiento de OAuth

Si usas un proyecto nuevo de Google Cloud para completar esta guía de inicio rápido, configura la pantalla de consentimiento de OAuth. Si ya completaste este paso para tu proyecto de Cloud, pasa a la siguiente sección.

1. En la Consola de APIs de Google, ve a Menú > Plataforma de autenticación de Google > Branding.

   Ir a Branding

2. Si ya configuraste la plataforma de autenticación de Google, puedes configurar los siguientes parámetros de configuración de la pantalla de consentimiento de OAuth en Branding, Público y Acceso a los datos. Si ves un mensaje que dice Aún no se configuró la plataforma de autenticación de Google, haz clic en Comenzar:
1. En Información de la app, en Nombre de la app, ingresa un nombre para la app.
2. En Correo electrónico de asistencia al usuario, elige una dirección de correo electrónico de asistencia en la que los usuarios puedan comunicarse contigo si tienen preguntas sobre su consentimiento.
3. Haz clic en Siguiente.
4. En Público, selecciona Interno.
5. Haz clic en Siguiente.
6. En Información de contacto, ingresa una Dirección de correo electrónico en la que puedas recibir notificaciones sobre cualquier cambio en tu proyecto.
7. Haz clic en Siguiente.
8. En Finalizar, revisa la Política de Datos del Usuario de los Servicios de las APIs de Google y, si estás de acuerdo, selecciona Acepto la Política de Datos del Usuario de los Servicios de las APIs de Google.
9. Haz clic en Continuar.
10. Haz clic en Crear.
3. Por ahora, puedes omitir la adición de permisos. En el futuro, cuando crees una app para usar fuera de tu organización de Google Workspace, debes cambiar el Tipo de usuario a Externo. Luego, agrega los permisos de autorización que requiere tu app. Para obtener más información, consulta la guía completa Configura el consentimiento de OAuth guide.

Autoriza las credenciales para una aplicación de escritorio

Para autenticar a los usuarios finales y acceder a los datos del usuario en tu app, debes 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 la app se ejecuta en varias plataformas, debes crear un ID de cliente independiente para cada una.

1. En la Consola de APIs de Google, ve a Menú > Plataforma de autenticación de Google > Clientes.

   Ir a Clientes

2. Haz clic en Crear cliente.
3. Haz clic en Tipo de aplicación > Aplicación de escritorio.
4. En el campo Nombre, escribe un nombre para la credencial. Este nombre solo se muestra en la Consola de APIs de Google.
5. Haz clic en Crear.

   La credencial recién creada aparece en "IDs de cliente de OAuth 2.0".

6. Guarda el archivo JSON descargado como credentials.json y mueve el archivo a tu directorio de trabajo.

Prepara el lugar de trabajo

1. Crea 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 Calendar y el paquete OAuth2.0:

   go get google.golang.org/api/calendar/v3
   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:

   calendar/quickstart/quickstart.go

   Ver en GitHub
   package main
   
   import (
   	"context"
   	"encoding/json"
   	"fmt"
   	"log"
   	"net/http"
   	"os"
   	"time"
   
   	"golang.org/x/oauth2"
   	"golang.org/x/oauth2/google"
   	"google.golang.org/api/calendar/v3"
   	"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)
   }
   
   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, calendar.CalendarReadonlyScope)
   	if err != nil {
   		log.Fatalf("Unable to parse client secret file to config: %v", err)
   	}
   	client := getClient(config)
   
   	srv, err := calendar.NewService(ctx, option.WithHTTPClient(client))
   	if err != nil {
   		log.Fatalf("Unable to retrieve Calendar client: %v", err)
   	}
   
   	t := time.Now().Format(time.RFC3339)
   	events, err := srv.Events.List("primary").ShowDeleted(false).
   		SingleEvents(true).TimeMin(t).MaxResults(10).OrderBy("startTime").Do()
   	if err != nil {
   		log.Fatalf("Unable to retrieve next ten of the user's events: %v", err)
   	}
   	fmt.Println("Upcoming events:")
   	if len(events.Items) == 0 {
   		fmt.Println("No upcoming events found.")
   	} else {
   		for _, item := range events.Items {
   			date := item.Start.DateTime
   			if date == "" {
   				date = item.Start.Date
   			}
   			fmt.Printf("%v (%v)\n", item.Summary, date)
   		}
   	}
   }

Ejecuta la muestra

1. En el 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 usarla en la autorización.
   2. Haz clic en Aceptar.

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

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

Próximos pasos

• Prueba las APIs de Google Workspace en el Explorador de APIs
  • Cómo crear eventos
  • Soluciona problemas de autenticación y autorización
  • Documentación de referencia de la API de Calendar
  • Sección google-api-go-client de GitHub