Lettura e scrittura in Cloud Storage

Questo documento descrive come archiviare e recuperare i dati utilizzando la libreria client Cloud Storage. Si presume che tu abbia completato le attività descritte in Configurazione per Cloud Storage per attivare un bucket Cloud Storage e scaricare le librerie client. Inoltre, si presume che tu sappia come creare un'applicazione App Engine.

Per altri esempi di codice, consulta le librerie client di Cloud Storage .

Importazioni richieste

Le importazioni nel file richieste per App Engine e Cloud Storage sono:

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

come mostrato nello snippet seguente:

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

Specifica del bucket Cloud Storage

Prima di poter eseguire qualsiasi operazione su Cloud Storage, devi fornire il nome del bucket. Il modo più semplice per farlo è utilizzare il bucket predefinito per il progetto, che può essere ottenuto dal contesto App Engine, come mostrato in questo snippet:

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

Scrittura in Cloud Storage

Per scrivere un file in 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
	}
}

Quando viene creato il file, il campione specifica gli intestazioni Cloud Storage (x-goog-meta-foo e x-goog-meta-bar). Questo codice facoltativo introduce il concetto di utilizzo degli intestazioni Cloud Storage, che puoi applicare a:

  • Influiscono sul comportamento delle richieste
  • Specifica un accesso al file nel bucket diverso da quello predefinito (vedi x-goog-acl)
  • Scrivi i metadati del file.

Le intestazioni x-goog-meta-* mostrate sopra sono metadati dei file personalizzati che puoi impostare. Queste intestazioni vengono sempre restituite con il file. Tieni presente che lo spazio disponibile per le intestazioni personalizzate e i relativi dati è limitato a pochi kilobyte, quindi utilizzali con attenzione.

Poiché il esempio di codice non imposta x-goog-acl, l'ACL Cloud Storage predefinito di lettura pubblica viene applicato all'oggetto quando viene scritto nel bucket.

Infine, nota la chiamata a Close() del file al termine della scrittura. Se non lo fai, il file non viene scritto in Cloud Storage. Tieni presente che dopo aver chiamato Close(), non puoi aggiungere elementi al file.

Lettura da Cloud Storage

Per leggere un file da 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)
	}
}

Elenco dei contenuti del bucket

Questo codice campione mostra come elencare i contenuti del bucket:

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

Eliminazione di file in Cloud Storage

Il codice seguente mostra come eliminare un file da Cloud Storage utilizzando il metodo ObjectHandle.delete().


// deleteFiles deletes all the temporary files from a bucket created by this demo.
func (d *demo) deleteFiles() {
	io.WriteString(d.w, "\nDeleting files...\n")
	for _, v := range d.cleanUp {
		fmt.Fprintf(d.w, "Deleting file %v\n", v)
		if err := d.bucket.Object(v).Delete(d.ctx); err != nil {
			d.errorf("deleteFiles: unable to delete bucket %q, file %q: %v", d.bucketName, v, err)
			return
		}
	}
}

Questo esempio ripulisce i file scritti nel bucket nella sezione Scrittura in Cloud Storage.

Passaggi successivi