Muestra de App Engine y Google Cloud Storage

En este instructivo se muestra todo lo que necesitas hacer para permitir que tu aplicación de Go en App Engine acceda a Cloud Storage. En esta muestra no interactiva se indica cómo crear, escribir, leer y enumerar archivos en un depósito de Cloud Storage.

Cuando se ejecuta esta muestra, se ejecuta una secuencia de comandos que realiza varias acciones en el depósito de Cloud Storage y, a continuación, envía los detalles al navegador.

Objetivos

  • Implementar y ejecutar la aplicación de muestra en Google App Engine.
  • Aprender cómo crear un archivo y, a continuación, escribirlo en un depósito de Cloud Storage.
  • Aprender cómo leer archivos desde un depósito de Cloud Storage.
  • Aprender cómo copiar archivos en un depósito de Cloud Storage.
  • Aprender cómo enumerar los archivos que existen en Cloud Storage.

Costos

App Engine tiene un nivel de uso gratuito. Si el uso total de App Engine es menor que los límites especificados en la cuota gratuita de App Engine, no se aplican cargos por este instructivo.

Antes de comenzar

  1. Crea o selecciona un proyecto de GCP en GCP Console y, a continuación, asegúrate de que el proyecto incluya una aplicación de App Engine:

    Ir a App Engine

    El Panel se abrirá si ya existe una aplicación de App Engine en tu proyecto. De lo contrario, se te solicitará que selecciones la región donde quieres que se ubique la aplicación de App Engine.

  2. Instala y descarga el SDK para App Engine.

  3. Configura Cloud Storage:

    1. Activa el depósito de Cloud Storage predeterminado.

    2. Descarga y luego instala la biblioteca cliente de Cloud Storage.

Cómo descargar el proyecto de muestra

Para descargar el proyecto, elige cualquiera de los métodos que se indican a continuación:

  • Clonar el proyecto que contiene el código de muestra:

    go get -u -d github.com/GoogleCloudPlatform/golang-samples/docs/appengine/storage
    
  • Descargar la muestra como un archivo .zip y, a continuación, extraerlo en el directorio de trabajo.

Cómo implementar y ejecutar la muestra

Para implementar la aplicación de muestra en App Engine y ver la muestra en el navegador, completa los siguientes pasos:

  1. Ve al directorio que contiene el código de muestra:

    cd $GOPATH/src/github.com/GoogleCloudPlatform/golang-samples/docs/appengine/storage
    
  2. Ejecuta el siguiente comando desde el directorio raíz de la aplicación donde se encuentra el archivo app.yaml, por ejemplo, golang-samples/docs/appengine/storage:

    gcloud app deploy
    

    Para obtener más información sobre la implementación de la aplicación desde la línea de comandos, consulta Implementa una aplicación de Go.

  3. Inicia el navegador a fin de ver la muestra en http://[YOUR_PROJECT_ID].appspot.com; para ello, ejecuta el siguiente comando:

    gcloud app browse
    
  4. Revisa los resultados de la aplicación. El navegador debe mostrar los detalles para cada una de las acciones que realizó la secuencia de comandos en el depósito de Cloud Storage.

    Además de escribir, leer, copiar y enumerar los archivos, la aplicación de muestra también permite visualizar los permisos de objetos, manipula las listas de control de acceso (LCA) y, luego, borra todos los archivos de demostración del depósito de Cloud Storage.

    Resultados de ejemplo:

    muestra de demostración

Explicación del código

Esta explicación solo abarca cómo leer y escribir un depósito de Cloud Storage y enumerar el contenido del depósito, a pesar de que el código de muestra contiene funciones adicionales de Cloud Storage.

Explicación de app.yaml

La configuración del archivo app.yaml es típica para casi cualquier aplicación. Como toda aplicación de App Engine, te permite especificar los detalles de configuración de la aplicación:

application: your-app-id
version: v1
runtime: go
api_version: go1

handlers:
- url: /.*
  script: _go_app

Para obtener más información sobre las opciones de configuración disponibles en este archivo, consulta la referencia app.yaml.

Explicación de importaciones de app.go

El archivo app.go contiene estas importaciones:

import (
	"bytes"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"strings"

	"cloud.google.com/go/storage"
	"golang.org/x/net/context"
	"google.golang.org/api/iterator"
	"google.golang.org/appengine"
	"google.golang.org/appengine/file"
	"google.golang.org/appengine/log"
)

Las importaciones en el archivo que se requieren para App Engine y Cloud Storage son las siguientes:

  • google.golang.org/appengine
  • google.golang.org/appengine/file
  • cloud.google.com/go/storage

Cómo especificar el depósito de Cloud Storage

Antes de que puedas ejecutar cualquier operación de Cloud Storage, debes proporcionar el nombre del depósito. La manera más sencilla de hacerlo es utilizar el depósito predeterminado para el proyecto, que se puede obtener del contexto de App Engine:

// Use `dev_appserver.py --default_gcs_bucket_name GCS_BUCKET_NAME`
// when running locally.
bucket, err := file.DefaultBucketName(ctx)
if err != nil {
	log.Errorf(ctx, "failed to get default GCS bucket name: %v", err)
}

Cómo escribir un archivo en Cloud Storage

Para escribir un archivo en Cloud Storage:

// createFile creates a file in Google Cloud Storage.
func (d *demo) createFile(fileName string) {
	fmt.Fprintf(d.w, "Creating file /%v/%v\n", d.bucketName, fileName)

	wc := d.bucket.Object(fileName).NewWriter(d.ctx)
	wc.ContentType = "text/plain"
	wc.Metadata = map[string]string{
		"x-goog-meta-foo": "foo",
		"x-goog-meta-bar": "bar",
	}
	d.cleanUp = append(d.cleanUp, fileName)

	if _, err := wc.Write([]byte("abcde\n")); err != nil {
		d.errorf("createFile: unable to write data to bucket %q, file %q: %v", d.bucketName, fileName, err)
		return
	}
	if _, err := wc.Write([]byte(strings.Repeat("f", 1024*4) + "\n")); err != nil {
		d.errorf("createFile: unable to write data to bucket %q, file %q: %v", d.bucketName, fileName, err)
		return
	}
	if err := wc.Close(); err != nil {
		d.errorf("createFile: unable to close bucket %q, file %q: %v", d.bucketName, fileName, err)
		return
	}
}

Cuando se crea el archivo, la muestra especifica los encabezados de Cloud Storage (x-goog-meta-foo y x-goog-meta-bar). Este código opcional presenta la idea de usar encabezados de Cloud Storage, que puedes utilizar para lo siguiente:

  • Afectar el comportamiento de la solicitud.
  • Especificar el acceso a un archivo en el depósito de Cloud Storage que sea diferente de los valores predeterminados. Consulta x-goog-acl para obtener más información.
  • Escribir los metadatos del archivo.

Los encabezados x-goog-meta- que se mostraron con anterioridad son metadatos de archivos personalizados que puedes configurar; estos encabezados siempre se muestran con el archivo. Ten en cuenta que el espacio disponible para los encabezados personalizados y sus datos se limita a unos pocos kilobytes, así que utilízalos con cuidado.

Debido a que el ejemplo del código no establece x-goog-acl, la LCA predeterminada de Cloud Storage de lectura pública se aplica al objeto cuando se lo escribe en el depósito.

Por último, presta atención a la llamada a Close en el archivo después de terminar la escritura. Si no lo haces, el archivo no se escribirá en Cloud Storage. Ten en cuenta que después de llamar a Close, no puedes adjuntar el archivo.

Cómo leer un archivo desde Cloud Storage

Para leer un archivo desde Cloud Storage:

// readFile reads the named file in Google Cloud Storage.
func (d *demo) readFile(fileName string) {
	io.WriteString(d.w, "\nAbbreviated file content (first line and last 1K):\n")

	rc, err := d.bucket.Object(fileName).NewReader(d.ctx)
	if err != nil {
		d.errorf("readFile: unable to open file from bucket %q, file %q: %v", d.bucketName, fileName, err)
		return
	}
	defer rc.Close()
	slurp, err := ioutil.ReadAll(rc)
	if err != nil {
		d.errorf("readFile: unable to read data from bucket %q, file %q: %v", d.bucketName, fileName, err)
		return
	}

	fmt.Fprintf(d.w, "%s\n", bytes.SplitN(slurp, []byte("\n"), 2)[0])
	if len(slurp) > 1024 {
		fmt.Fprintf(d.w, "...%s\n", slurp[len(slurp)-1024:])
	} else {
		fmt.Fprintf(d.w, "%s\n", slurp)
	}
}

Cómo enumerar el contenido del depósito

Este código de muestra indica cómo enumerar el contenido del depósito:

// listBucket lists the contents of a bucket in Google Cloud Storage.
func (d *demo) listBucket() {
	io.WriteString(d.w, "\nListbucket result:\n")

	query := &storage.Query{Prefix: "foo"}
	it := d.bucket.Objects(d.ctx, query)
	for {
		obj, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			d.errorf("listBucket: unable to list bucket %q: %v", d.bucketName, err)
			return
		}
		d.dumpStats(obj)
	}
}

Cómo copiar los archivos de Cloud Storage

Este código de muestra indica cómo enumerar el contenido del depósito:

// copyFile copies a file in Google Cloud Storage.
func (d *demo) copyFile(fileName string) {
	copyName := fileName + "-copy"
	fmt.Fprintf(d.w, "Copying file /%v/%v to /%v/%v:\n", d.bucketName, fileName, d.bucketName, copyName)

	obj, err := d.bucket.Object(copyName).CopierFrom(d.bucket.Object(fileName)).Run(d.ctx)
	if err != nil {
		d.errorf("copyFile: unable to copy /%v/%v to bucket %q, file %q: %v", d.bucketName, fileName, d.bucketName, copyName, err)
		return
	}
	d.cleanUp = append(d.cleanUp, copyName)

	d.dumpStats(obj)
}

¿Qué sigue?

Obtén más información sobre los siguientes temas:

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Entorno estándar de App Engine para Go