Hospedar um site estático

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Neste tutorial, descrevemos como configurar um bucket do Cloud Storage para hospedar um site estático de um domínio seu. As páginas da Web estáticas podem conter tecnologias de cliente, como HTML, CSS e JavaScript. Eles não podem conter conteúdo dinâmico, como scripts do servidor, como PHP.

Como o Cloud Storage não é compatível com domínios personalizados com HTTPS por conta própria, este tutorial usa o Cloud Storage com balanceamento de carga HTTP(S) para exibir conteúdo de um domínio personalizado por HTTPS. Para ver mais maneiras de exibir conteúdo de um domínio personalizado por HTTPS, consulte Solução de problemas de exibição de HTTPS. Também é possível usar o Cloud Storage para exibir conteúdo de domínio personalizado por HTTP, que não requer um balanceador de carga.

Para exemplos e dicas sobre páginas da Web estáticas, incluindo como hospedar recursos estáticos para um site dinâmico, consulte Página do site estático.

Objetivos

Neste tutorial, mostramos como fazer as seguintes tarefas:

  • Crie um bucket.
  • fazer o upload de arquivos do seu site e compartilhá-los;
  • Configure um balanceador de carga e um certificado SSL.
  • Conecte o balanceador de carga ao bucket.
  • Aponte seu domínio para o balanceador de carga usando um registro A.
  • testar o site.

Custos

Neste tutorial, usamos o seguinte componente faturável do Google Cloud:

Consulte a dica Como monitorar cobranças para mais detalhes sobre as cobranças que podem ser geradas ao hospedar um site estático.

Antes de começar

  1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.
  2. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  3. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

  4. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

    Acessar o seletor de projetos

  5. Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como verificar se o faturamento está ativado em um projeto.

  6. Ative a API Compute Engine no projeto.
  7. Tenha os seguintes papéis do Identity and Access Management: Administrador de objetos do Storage e Administrador de rede do Compute
  8. Tenha um domínio próprio ou que você gerencia. Se você não tiver um domínio, há muitos serviços pelos quais você pode registrar um novo domínio, como Google Domains e Cloud Domains.

    Este tutorial usa o domínio example.com.

  9. Tenha alguns arquivos de site que você quer exibir. Este tutorial funcionará melhor se você tiver pelo menos uma página de índice (index.html) e uma página 404 (404.html).
  10. (Opcional) Se você quiser que o bucket do Cloud Storage tenha o mesmo nome do domínio, será necessário verificar se você é proprietário ou administrador do domínio que será usado de dados. Certifique-se de estar verificando o domínio de nível mais alto, como example.com, e não um subdomínio, como www.example.com. Se você comprou seu domínio pelo Google Domains, a confirmação será automática.

Crie um bucket

Para criar um bucket:

Console

  1. No Console do Cloud, acesse a página Buckets do Cloud Storage.

    Acessar buckets

  2. Clique em Criar bucket.
  3. Na página Criar um bucket, insira as informações do seu bucket. Para ir à próxima etapa, clique em Continuar.
    • Em Nomear o bucket, insira um nome que atenda aos requisitos de nome de bucket.
    • Em Escolha onde armazenar os dados, selecione o Tipo de local e o Local onde os dados do bucket serão armazenados permanentemente.
    • Em Escolha uma classe de armazenamento para seus dados, selecione uma classe de armazenamento padrão para o bucket ou selecione Classe automática para gerenciamento automático da classe de armazenamento dos dados do bucket.

      Observação: o painel Estimativa de custo mensal no painel direito estima os custos mensais do bucket com base na classe e no local de armazenamento selecionados, bem como no tamanho e nas operações dos dados.

    • Em Escolha como controlar o acesso a objetos, selecione se o bucket aplica a prevenção de acesso público e um modelo de Controle de acesso para os objetos do bucket.

      Observação: se a prevenção de acesso público já estiver aplicada pela política da organização do projeto, a opção Impedir acesso público ficará bloqueada.

    • Em Escolher como proteger os dados do objeto, configure Ferramentas de proteção se quiser e selecione um método de Criptografia de dados.
  4. Clique em Criar.

Para saber como acessar informações detalhadas de erro sobre operações do Cloud Storage com falha no console do Google Cloud, consulte Solução de problemas.

Linha de comando

gcloud

Use o comando gcloud storage buckets create:

gcloud storage buckets create gs://BUCKET_NAME

Em que:

Se a solicitação for bem-sucedida, o comando retornará a seguinte mensagem:

Creating gs://BUCKET_NAME/...

Para ter mais controle sobre a criação do bucket, defina as seguintes sinalizações opcionais:

  • --project: especifique o ID ou o número do projeto ao qual seu bucket será associado. Por exemplo, my-project.
  • --default-storage-class: especifique a classe de armazenamento padrão do bucket. Por exemplo, NEARLINE.
  • --location: especifique a localização do bucket. Por exemplo, US-EAST1.
  • --uniform-bucket-level-access: ative o acesso uniforme no nível do bucket para seu bucket.
  • Para ver uma lista completa de opções de criação de buckets do gcloud, consulte opções de buckets create.

Exemplo:

gcloud storage buckets create gs://BUCKET_NAME --project=PROJECT_ID --default-storage-class=STORAGE_CLASS --location=BUCKET_LOCATION --uniform-bucket-level-access

gsutil

Use o comando gsutil mb:

gsutil mb gs://BUCKET_NAME

Em que:

Se a solicitação for bem-sucedida, o comando retornará a seguinte mensagem:

Creating gs://BUCKET_NAME/...

Para ter mais controle sobre a criação do bucket, defina as seguintes sinalizações opcionais:

  • -p: especifique o ID ou o número do projeto ao qual seu bucket será associado. Por exemplo, my-project.
  • -c: especifique a classe de armazenamento padrão do bucket. Por exemplo, NEARLINE.
  • -l: especifique a localização do bucket. Por exemplo, US-EAST1.
  • -b: especifique a configuração Acesso uniforme no nível do bucket para o bucket. Por exemplo, ON.
  • Para uma lista completa de opções para criação de buckets da gsutil, consulte opções mb.

Exemplo:

gsutil mb -p PROJECT_ID -c STORAGE_CLASS -l BUCKET_LOCATION -b on gs://BUCKET_NAME

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& storage_class, std::string const& location) {
  StatusOr<gcs::BucketMetadata> bucket_metadata =
      client.CreateBucket(bucket_name, gcs::BucketMetadata()
                                           .set_storage_class(storage_class)
                                           .set_location(location));

  if (!bucket_metadata) {
    throw std::runtime_error(bucket_metadata.status().message());
  }

  std::cout << "Bucket " << bucket_metadata->name() << " created."
            << "\nFull Metadata: " << *bucket_metadata << "\n";
}

C#

Para mais informações, consulte a documentação de referência da API Cloud Storage C#.


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class CreateRegionalBucketSample
{
    /// <summary>
    /// Creates a storage bucket with region.
    /// </summary>
    /// <param name="projectId">The ID of the project to create the buckets in.</param>
    /// <param name="location">The location of the bucket. Object data for objects in the bucket resides in
    /// physical storage within this region. Defaults to US.</param>
    /// <param name="bucketName">The name of the bucket to create.</param>
    /// <param name="storageClass">The bucket's default storage class, used whenever no storageClass is specified
    /// for a newly-created object. This defines how objects in the bucket are stored
    /// and determines the SLA and the cost of storage. Values include MULTI_REGIONAL,
    /// REGIONAL, STANDARD, NEARLINE, COLDLINE, ARCHIVE, and DURABLE_REDUCED_AVAILABILITY.
    /// If this value is not specified when the bucket is created, it will default to
    /// STANDARD.</param>
    public Bucket CreateRegionalBucket(
        string projectId = "your-project-id",
        string bucketName = "your-unique-bucket-name",
        string location = "us-west1",
        string storageClass = "REGIONAL")
    {
        var storage = StorageClient.Create();
        Bucket bucket = new Bucket
        {
            Location = location,
            Name = bucketName,
            StorageClass = storageClass
        };
        var newlyCreatedBucket = storage.CreateBucket(projectId, bucket);
        Console.WriteLine($"Created {bucketName}.");
        return newlyCreatedBucket;
    }
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// createBucketClassLocation creates a new bucket in the project with Storage class and
// location.
func createBucketClassLocation(w io.Writer, projectID, bucketName string) error {
	// projectID := "my-project-id"
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*30)
	defer cancel()

	storageClassAndLocation := &storage.BucketAttrs{
		StorageClass: "COLDLINE",
		Location:     "asia",
	}
	bucket := client.Bucket(bucketName)
	if err := bucket.Create(ctx, projectID, storageClassAndLocation); err != nil {
		return fmt.Errorf("Bucket(%q).Create: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Created bucket %v in %v with storage class %v\n", bucketName, storageClassAndLocation.Location, storageClassAndLocation.StorageClass)
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.BucketInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageClass;
import com.google.cloud.storage.StorageOptions;

public class CreateBucketWithStorageClassAndLocation {
  public static void createBucketWithStorageClassAndLocation(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID to give your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();

    // See the StorageClass documentation for other valid storage classes:
    // https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
    StorageClass storageClass = StorageClass.COLDLINE;

    // See this documentation for other valid locations:
    // http://g.co/cloud/storage/docs/bucket-locations#location-mr
    String location = "ASIA";

    Bucket bucket =
        storage.create(
            BucketInfo.newBuilder(bucketName)
                .setStorageClass(storageClass)
                .setLocation(location)
                .build());

    System.out.println(
        "Created bucket "
            + bucket.getName()
            + " in "
            + bucket.getLocation()
            + " with storage class "
            + bucket.getStorageClass());
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of a storage class
// See the StorageClass documentation for other valid storage classes:
// https://googleapis.dev/java/google-cloud-clients/latest/com/google/cloud/storage/StorageClass.html
// const storageClass = 'coldline';

// The name of a location
// See this documentation for other valid locations:
// http://g.co/cloud/storage/docs/locations#location-mr
// const location = 'ASIA';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
// The bucket in the sample below will be created in the project associated with this client.
// For more information, please see https://cloud.google.com/docs/authentication/production or https://googleapis.dev/nodejs/storage/latest/Storage.html
const storage = new Storage();

async function createBucketWithStorageClassAndLocation() {
  // For default values see: https://cloud.google.com/storage/docs/locations and
  // https://cloud.google.com/storage/docs/storage-classes
  const [bucket] = await storage.createBucket(bucketName, {
    location,
    [storageClass]: true,
  });

  console.log(
    `${bucket.name} created with ${storageClass} class in ${location}`
  );
}

createBucketWithStorageClassAndLocation().catch(console.error);

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Create a new bucket with a custom default storage class and location.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 */
function create_bucket_class_location(string $bucketName): void
{
    $storage = new StorageClient();
    $storageClass = 'COLDLINE';
    $location = 'ASIA';
    $bucket = $storage->createBucket($bucketName, [
        'storageClass' => $storageClass,
        'location' => $location,
    ]);

    $objects = $bucket->objects([
        'encryption' => [
            'defaultKmsKeyName' => null,
        ]
    ]);

    printf('Created bucket %s in %s with storage class %s', $bucketName, $storageClass, $location);
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

from google.cloud import storage

def create_bucket_class_location(bucket_name):
    """
    Create a new bucket in the US region with the coldline storage
    class
    """
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.bucket(bucket_name)
    bucket.storage_class = "COLDLINE"
    new_bucket = storage_client.create_bucket(bucket, location="us")

    print(
        "Created bucket {} in {} with storage class {}".format(
            new_bucket.name, new_bucket.location, new_bucket.storage_class
        )
    )
    return new_bucket

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

def create_bucket_class_location bucket_name:
  # The ID to give your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.create_bucket bucket_name,
                                  location:      "ASIA",
                                  storage_class: "COLDLINE"

  puts "Created bucket #{bucket.name} in #{bucket.location} with #{bucket.storage_class} class"
end

Terraform

É possível usar um recurso Terraform para criar um bucket de armazenamento.

O exemplo a seguir inclui a atribuição de um sufixo de página de índice e uma página de erros personalizada. Para mais informações, consulte Atribuir páginas de especialidades.

# Create new storage bucket in the US multi-region
# with coldline storage and settings for main_page_suffix and not_found_page
resource "random_id" "bucket_prefix" {
  byte_length = 8
}

resource "google_storage_bucket" "static_website" {
  name          = "${random_id.bucket_prefix.hex}-static-website-bucket"
  location      = "US"
  storage_class = "COLDLINE"
  website {
    main_page_suffix = "index.html"
    not_found_page   = "index.html"
  }
}

APIs REST

API JSON

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Crie um arquivo .json com as configurações do bucket, que precisa incluir um name para o bucket. Consulte a documentação Buckets:Insert para ver uma lista completa de configurações. Veja a seguir configurações comuns a serem incluídas:
  3. {
      "name": "BUCKET_NAME",
      "location": "BUCKET_LOCATION",
      "storageClass": "STORAGE_CLASS",
      "iamConfiguration": {
        "uniformBucketLevelAccess": {
          "enabled": true
        },
      }
    }

    Em que:

  4. Use cURL (em inglês) para chamar a API JSON:
    curl -X POST --data-binary @JSON_FILE_NAME.json \
         -H "Authorization: Bearer OAUTH2_TOKEN" \
         -H "Content-Type: application/json" \
         "https://storage.googleapis.com/storage/v1/b?project=PROJECT_IDENTIFIER"

    Em que:

    • JSON_FILE_NAME é o nome do arquivo JSON criado na Etapa 2.
    • OAUTH2_TOKEN é o token de acesso gerado na Etapa 1.
    • PROJECT_IDENTIFIER é o ID ou o número do projeto ao qual seu bucket será associado. Por exemplo, my-project.

API XML

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Crie um arquivo .xml com as informações a seguir:
  3. <CreateBucketConfiguration>
       <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
       <StorageClass>STORAGE_CLASS</StorageClass>
    </CreateBucketConfiguration>

    Em que:

  4. Use cURL (em inglês) para chamar a API XML:
    curl -X PUT --data-binary @XML_FILE_NAME.xml \
         -H "Authorization: Bearer OAUTH2_TOKEN" \
         -H "x-goog-project-id: PROJECT_ID" \
         "https://storage.googleapis.com/BUCKET_NAME"

    Em que:

    • XML_FILE_NAME é o nome do arquivo XML criado na Etapa 2.
    • OAUTH2_TOKEN é o token de acesso gerado na Etapa 1.
    • PROJECT_ID é o ID do projeto ao qual o bucket será associado. Por exemplo, my-project.
    • BUCKET_NAME é o nome que você quer dar ao bucket, sujeito a requisitos de nomenclatura. Por exemplo, my-bucket.

Fazer upload dos arquivos do seu site

Adicione os arquivos que você pretende que seu site veicule ao bucket:

Console

  1. No Console do Cloud, acesse a página Buckets do Cloud Storage.

    Acessar buckets

  2. Na lista de buckets, clique no nome do bucket que você criou.

    A página Detalhes do bucket é aberta, com a guia Objetos selecionada.

  3. Clique no botão Enviar arquivos.

  4. Na caixa de diálogo de arquivos, procure e selecione o arquivo desejado.

Após a conclusão do upload, você verá o nome do arquivo com as informações do arquivo exibidas no bucket.

Para saber como acessar informações detalhadas de erro sobre operações do Cloud Storage com falha no console do Google Cloud, consulte Solução de problemas.

gsutil

Use o comando gsutil cp para copiar arquivos para o bucket. Por exemplo, para copiar o arquivo index.html do local atual Desktop para o bucket my-static-assets:

gsutil cp Desktop/index.html gs://my-static-assets

Se o comando estiver correto, ele retornará:

Copying file://Desktop/index.html [Content-Type=text/html]...
Uploading   gs://my-static-assets/index.html:       0 B/2.58 KiB
Uploading   gs://my-static-assets/index.html:       2.58 KiB/2.58 KiB

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

No exemplo a seguir, um objeto é enviado de um arquivo:

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& file_name,
   std::string const& bucket_name, std::string const& object_name) {
  // Note that the client library automatically computes a hash on the
  // client-side to verify data integrity during transmission.
  StatusOr<gcs::ObjectMetadata> metadata = client.UploadFile(
      file_name, bucket_name, object_name, gcs::IfGenerationMatch(0));
  if (!metadata) throw std::runtime_error(metadata.status().message());

  std::cout << "Uploaded " << file_name << " to object " << metadata->name()
            << " in bucket " << metadata->bucket()
            << "\nFull metadata: " << *metadata << "\n";
}

C#

Para mais informações, consulte a documentação de referência da API Cloud Storage C#.

No exemplo a seguir, um objeto é enviado de um arquivo:


using Google.Cloud.Storage.V1;
using System;
using System.IO;

public class UploadFileSample
{
    public void UploadFile(
        string bucketName = "your-unique-bucket-name",
        string localPath = "my-local-path/my-file-name",
        string objectName = "my-file-name")
    {
        var storage = StorageClient.Create();
        using var fileStream = File.OpenRead(localPath);
        storage.UploadObject(bucketName, objectName, null, fileStream);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

No exemplo a seguir, um objeto é enviado de um arquivo:

import (
	"context"
	"fmt"
	"io"
	"os"
	"time"

	"cloud.google.com/go/storage"
)

// uploadFile uploads an object.
func uploadFile(w io.Writer, bucket, object string) error {
	// bucket := "bucket-name"
	// object := "object-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	// Open local file.
	f, err := os.Open("notes.txt")
	if err != nil {
		return fmt.Errorf("os.Open: %v", err)
	}
	defer f.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*50)
	defer cancel()

	o := client.Bucket(bucket).Object(object)

	// Optional: set a generation-match precondition to avoid potential race
	// conditions and data corruptions. The request to upload is aborted if the
	// object's generation number does not match your precondition.
	// For an object that does not yet exist, set the DoesNotExist precondition.
	o = o.If(storage.Conditions{DoesNotExist: true})
	// If the live object already exists in your bucket, set instead a
	// generation-match precondition using the live object's generation number.
	// attrs, err := o.Attrs(ctx)
	// if err != nil {
	// 	return fmt.Errorf("object.Attrs: %v", err)
	// }
	// o = o.If(storage.Conditions{GenerationMatch: attrs.Generation})

	// Upload an object with storage.Writer.
	wc := o.NewWriter(ctx)
	if _, err = io.Copy(wc, f); err != nil {
		return fmt.Errorf("io.Copy: %v", err)
	}
	if err := wc.Close(); err != nil {
		return fmt.Errorf("Writer.Close: %v", err)
	}
	fmt.Fprintf(w, "Blob %v uploaded.\n", object)
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

No exemplo a seguir, um objeto é enviado de um arquivo:


import com.google.cloud.storage.BlobId;
import com.google.cloud.storage.BlobInfo;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class UploadObject {
  public static void uploadObject(
      String projectId, String bucketName, String objectName, String filePath) throws IOException {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    // The ID of your GCS object
    // String objectName = "your-object-name";

    // The path to your file to upload
    // String filePath = "path/to/your/file"

    // Optional: set a generation-match precondition to avoid potential race
    // conditions and data corruptions. The request returns a 412 error if the
    // preconditions are not met.
    // For a target object that does not yet exist, set the DoesNotExist precondition.
    Storage.BlobTargetOption precondition = Storage.BlobTargetOption.doesNotExist();
    // If the destination already exists in your bucket, instead set a generation-match
    // precondition:
    // Storage.BlobTargetOption precondition = Storage.BlobTargetOption.generationMatch();

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    BlobId blobId = BlobId.of(bucketName, objectName);
    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();
    storage.create(blobInfo, Files.readAllBytes(Paths.get(filePath)), precondition);

    System.out.println(
        "File " + filePath + " uploaded to bucket " + bucketName + " as " + objectName);
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

No exemplo a seguir, um objeto é enviado de um arquivo:

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The path to your file to upload
// const filePath = 'path/to/your/file';

// The new ID for your GCS file
// const destFileName = 'your-new-file-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function uploadFile() {
  const options = {
    destination: destFileName,
    // Optional:
    // Set a generation-match precondition to avoid potential race conditions
    // and data corruptions. The request to upload is aborted if the object's
    // generation number does not match your precondition. For a destination
    // object that does not yet exist, set the ifGenerationMatch precondition to 0
    // If the destination object already exists in your bucket, set instead a
    // generation-match precondition using its generation number.
    preconditionOpts: {ifGenerationMatch: generationMatchPrecondition},
  };

  await storage.bucket(bucketName).upload(filePath, options);
  console.log(`${filePath} uploaded to ${bucketName}`);
}

uploadFile().catch(console.error);

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage PHP.

No exemplo a seguir, um objeto é enviado de um arquivo:

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $objectName The name of your Cloud Storage object.
 *        (e.g. 'my-object')
 * @param string $source The path to the file to upload.
 *        (e.g. '/path/to/your/file')
 */
function upload_object(string $bucketName, string $objectName, string $source): void
{
    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName
    ]);
    printf('Uploaded %s to gs://%s/%s' . PHP_EOL, basename($source), $bucketName, $objectName);
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

No exemplo a seguir, um objeto é enviado de um arquivo:

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # The ID of your GCS bucket
    # bucket_name = "your-bucket-name"
    # The path to your file to upload
    # source_file_name = "local/path/to/file"
    # The ID of your GCS object
    # destination_blob_name = "storage-object-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)
    blob = bucket.blob(destination_blob_name)

    blob.upload_from_filename(source_file_name)

    print(
        f"File {source_file_name} uploaded to {destination_blob_name}."
    )

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

No exemplo a seguir, um objeto é enviado de um arquivo:

def upload_file bucket_name:, local_file_path:, file_name: nil
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  # The path to your file to upload
  # local_file_path = "/local/path/to/file.txt"

  # The ID of your GCS object
  # file_name = "your-file-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket  = storage.bucket bucket_name, skip_lookup: true

  file = bucket.create_file local_file_path, file_name

  puts "Uploaded #{local_file_path} as #{file.name} in bucket #{bucket_name}"
end

Terraform

# Upload a simple index.html page to the bucket
resource "google_storage_bucket_object" "indexpage" {
  name         = "index.html"
  content      = "<html><body>Hello World!</body></html>"
  content_type = "text/html"
  bucket       = google_storage_bucket.static_website.id
}

# Upload a simple 404 / error page to the bucket
resource "google_storage_bucket_object" "errorpage" {
  name         = "404.html"
  content      = "<html><body>404!</body></html>"
  content_type = "text/html"
  bucket       = google_storage_bucket.static_website.id
}

APIs REST

API JSON

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Use cURL (em inglês) para chamar a API JSON com uma solicitação do objeto POST. Para o arquivo index.html enviado a um bucket chamado my-static-assets:

    curl -X POST --data-binary @index.html \
      -H "Content-Type: text/html" \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      "https://storage.googleapis.com/upload/storage/v1/b/my-static-assets/o?uploadType=media&name=index.html"

API XML

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Use cURL (em inglês) para chamar a API XML com uma solicitação do objeto PUT. Para o arquivo index.html enviado a um bucket chamado my-static-assets:

    curl -X PUT --data-binary @index.html \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      -H "Content-Type: text/html" \
      "https://storage.googleapis.com/my-static-assets/index.html"

Compartilhe seus arquivos

Para ativar a leitura de todos os objetos no seu bucket para todos os usuários da Internet pública, siga estas etapas:

Console

  1. No Console do Cloud, acesse a página Buckets do Cloud Storage.

    Acessar buckets

  2. Na lista de buckets, clique no nome do bucket que você quer tornar público.

  3. Selecione a guia Permissões na parte superior da página.

  4. Clique no botão + Adicionar.

    A caixa de diálogo Adicionar participantes é exibida.

  5. No campo Novos participantes, insira allUsers.

  6. No campo Selecionar uma função, selecione o submenu Cloud Storage e clique na opção Leitor de objetos do Storage.

  7. Clique em Salvar.

  8. Clique em Permitir acesso público.

Depois que o intervalo for compartilhado publicamente, aparecerá um ícone de link para cada objeto na coluna de acesso público. Clique nesse ícone para ver o URL do objeto.

Para saber como acessar informações detalhadas de erro sobre operações do Cloud Storage com falha no console do Google Cloud, consulte Solução de problemas.

gsutil

Use o comando gsutil iam ch:

gsutil iam ch allUsers:objectViewer gs://my-static-assets

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  auto current_policy = client.GetNativeBucketIamPolicy(
      bucket_name, gcs::RequestedPolicyVersion(3));

  if (!current_policy) {
    throw std::runtime_error(current_policy.status().message());
  }

  current_policy->set_version(3);
  current_policy->bindings().emplace_back(
      gcs::NativeIamBinding("roles/storage.objectViewer", {"allUsers"}));

  auto updated =
      client.SetNativeBucketIamPolicy(bucket_name, *current_policy);
  if (!updated) throw std::runtime_error(updated.status().message());

  std::cout << "Policy successfully updated: " << *updated << "\n";
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/iam"
	"cloud.google.com/go/storage"
	iampb "google.golang.org/genproto/googleapis/iam/v1"
)

// setBucketPublicIAM makes all objects in a bucket publicly readable.
func setBucketPublicIAM(w io.Writer, bucketName string) error {
	// bucketName := "bucket-name"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	policy, err := client.Bucket(bucketName).IAM().V3().Policy(ctx)
	if err != nil {
		return fmt.Errorf("Bucket(%q).IAM().V3().Policy: %v", bucketName, err)
	}
	role := "roles/storage.objectViewer"
	policy.Bindings = append(policy.Bindings, &iampb.Binding{
		Role:    role,
		Members: []string{iam.AllUsers},
	})
	if err := client.Bucket(bucketName).IAM().V3().SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("Bucket(%q).IAM().SetPolicy: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Bucket %v is now publicly readable\n", bucketName)
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

import com.google.cloud.Identity;
import com.google.cloud.Policy;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;
import com.google.cloud.storage.StorageRoles;

public class MakeBucketPublic {
  public static void makeBucketPublic(String projectId, String bucketName) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your GCS bucket
    // String bucketName = "your-unique-bucket-name";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Policy originalPolicy = storage.getIamPolicy(bucketName);
    storage.setIamPolicy(
        bucketName,
        originalPolicy
            .toBuilder()
            .addIdentity(StorageRoles.objectViewer(), Identity.allUsers()) // All users can view
            .build());

    System.out.println("Bucket " + bucketName + " is now publicly readable");
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function makeBucketPublic() {
  await storage.bucket(bucketName).makePublic();

  console.log(`Bucket ${bucketName} is now publicly readable`);
}

makeBucketPublic().catch(console.error);

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

from typing import List

from google.cloud import storage

def set_bucket_public_iam(
    bucket_name: str = "your-bucket-name",
    members: List[str] = ["allUsers"],
):
    """Set a public IAM Policy to bucket"""
    # bucket_name = "your-bucket-name"

    storage_client = storage.Client()
    bucket = storage_client.bucket(bucket_name)

    policy = bucket.get_iam_policy(requested_policy_version=3)
    policy.bindings.append(
        {"role": "roles/storage.objectViewer", "members": members}
    )

    bucket.set_iam_policy(policy)

    print(f"Bucket {bucket.name} is now publicly readable")

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

def set_bucket_public_iam bucket_name:
  # The ID of your GCS bucket
  # bucket_name = "your-unique-bucket-name"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  bucket.policy do |p|
    p.add "roles/storage.objectViewer", "allUsers"
  end

  puts "Bucket #{bucket_name} is now publicly readable"
end

Terraform

# Make bucket public by granting allUsers READER access
resource "google_storage_bucket_access_control" "public_rule" {
  bucket = google_storage_bucket.static_website.id
  role   = "READER"
  entity = "allUsers"
}

APIs REST

API JSON

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Crie um arquivo JSON com as informações a seguir:

    {
      "bindings":[
        {
          "role": "roles/storage.objectViewer",
          "members":["allUsers"]
        }
      ]
    }
  3. Use cURL para chamar a API JSON com uma solicitação bucket PUT:

    curl -X PUT --data-binary @JSON_FILE_NAME \
      -H "Authorization: Bearer OAUTH2_TOKEN" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/BUCKET_NAME/iam"

    Em que:

    • JSON_FILE_NAME é o caminho para o arquivo JSON criado na Etapa 2.
    • OAUTH2_TOKEN é o token de acesso criado na etapa 1;
    • BUCKET_NAME é o nome do bucket que contém os objetos que você quer tornar públicos. Por exemplo, my-static-assets.

API XML

Não é possível ativar a leitura pública de todos os objetos em um bucket com a API XML. Use a ferramenta gsutil ou a API JSON ou defina ACLs para cada objeto.

Para tornar objetos individuais no seu bucket acessíveis publicamente, é necessário mudar o modo Controle de acesso do seu bucket para Detalhado. Normalmente é mais fácil e rápido tornar todos os arquivos do seu bucket acessíveis publicamente.

Os visitantes recebem um código de resposta http 403 ao solicitar o URL de um arquivo não público ou inexistente. Consulte a próxima seção para obter informações sobre como adicionar uma página de erro que usa um http 404 código de resposta.

Recomendado: atribuir páginas especiais

É possível atribuir um sufixo de página de índice, controlado pela propriedade MainPageSuffix e por uma página de erro personalizada, controlada pela propriedade NotFoundPage. Atribuir um desses é opcional, mas sem uma página de índice, nada é exibido quando os usuários acessam seu site de nível superior, por exemplo, https://www.example.com. Saiba mais sobre as propriedades MainPageSuffix e NotFoundPage em Páginas especializadas.

No exemplo a seguir, o MainPageSuffix está definido como index.html e NotFoundPage está definido como 404.html:

Console

  1. No Console do Cloud, acesse a página Buckets do Cloud Storage.

    Acessar buckets

  2. Na lista de buckets, encontre o bucket que você criou.

  3. Clique no menu flutuante () associado ao bucket e selecione Editar configuração de site.

  4. Na caixa de diálogo de configuração do site, especifique a página principal e a página de erro.

  5. Clique em Salvar.

.

Para saber como acessar informações detalhadas de erro sobre operações do Cloud Storage com falha no console do Google Cloud, consulte Solução de problemas.

gsutil

Use o comando gsutil web set para definir a propriedade de MainPageSuffix com a sinalização de -m e NotFoundPage com a sinalização de -e:

gsutil web set -m index.html -e 404.html gs://my-static-assets

Se funcionar, o comando retornará:

Setting website config on gs://my-static-assets/...

Amostras de código

C++

Para mais informações, consulte a documentação de referência da API Cloud Storage C++.

namespace gcs = ::google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name,
   std::string const& main_page_suffix, std::string const& not_found_page) {
  StatusOr<gcs::BucketMetadata> original =
      client.GetBucketMetadata(bucket_name);

  if (!original) throw std::runtime_error(original.status().message());
  StatusOr<gcs::BucketMetadata> patched_metadata = client.PatchBucket(
      bucket_name,
      gcs::BucketMetadataPatchBuilder().SetWebsite(
          gcs::BucketWebsite{main_page_suffix, not_found_page}),
      gcs::IfMetagenerationMatch(original->metageneration()));

  if (!patched_metadata) {
    throw std::runtime_error(patched_metadata.status().message());
  }

  if (!patched_metadata->has_website()) {
    std::cout << "Static website configuration is not set for bucket "
              << patched_metadata->name() << "\n";
    return;
  }

  std::cout << "Static website configuration successfully set for bucket "
            << patched_metadata->name() << "\nNew main page suffix is: "
            << patched_metadata->website().main_page_suffix
            << "\nNew not found page is: "
            << patched_metadata->website().not_found_page << "\n";
}

C#

Para mais informações, consulte a documentação de referência da API Cloud Storage C#.


using Google.Apis.Storage.v1.Data;
using Google.Cloud.Storage.V1;
using System;

public class BucketWebsiteConfigurationSample
{
    public Bucket BucketWebsiteConfiguration(
        string bucketName = "your-bucket-name",
        string mainPageSuffix = "index.html",
        string notFoundPage = "404.html")
    {
        var storage = StorageClient.Create();
        var bucket = storage.GetBucket(bucketName);

        if (bucket.Website == null)
        {
            bucket.Website = new Bucket.WebsiteData();
        }
        bucket.Website.MainPageSuffix = mainPageSuffix;
        bucket.Website.NotFoundPage = notFoundPage;

        bucket = storage.UpdateBucket(bucket);
        Console.WriteLine($"Static website bucket {bucketName} is set up to use {mainPageSuffix} as the index page and {notFoundPage} as the 404 not found page.");
        return bucket;
    }
}

Go

Para mais informações, consulte a documentação de referência da API Cloud Storage Go.

import (
	"context"
	"fmt"
	"io"
	"time"

	"cloud.google.com/go/storage"
)

// setBucketWebsiteInfo sets website configuration on a bucket.
func setBucketWebsiteInfo(w io.Writer, bucketName, indexPage, notFoundPage string) error {
	// bucketName := "www.example.com"
	// indexPage := "index.html"
	// notFoundPage := "404.html"
	ctx := context.Background()
	client, err := storage.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("storage.NewClient: %v", err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(ctx, time.Second*10)
	defer cancel()

	bucket := client.Bucket(bucketName)
	bucketAttrsToUpdate := storage.BucketAttrsToUpdate{
		Website: &storage.BucketWebsite{
			MainPageSuffix: indexPage,
			NotFoundPage:   notFoundPage,
		},
	}
	if _, err := bucket.Update(ctx, bucketAttrsToUpdate); err != nil {
		return fmt.Errorf("Bucket(%q).Update: %v", bucketName, err)
	}
	fmt.Fprintf(w, "Static website bucket %v is set up to use %v as the index page and %v as the 404 page\n", bucketName, indexPage, notFoundPage)
	return nil
}

Java

Para mais informações, consulte a documentação de referência da API Cloud Storage Java.

import com.google.cloud.storage.Bucket;
import com.google.cloud.storage.Storage;
import com.google.cloud.storage.StorageOptions;

public class SetBucketWebsiteInfo {
  public static void setBucketWesbiteInfo(
      String projectId, String bucketName, String indexPage, String notFoundPage) {
    // The ID of your GCP project
    // String projectId = "your-project-id";

    // The ID of your static website bucket
    // String bucketName = "www.example.com";

    // The index page for a static website bucket
    // String indexPage = "index.html";

    // The 404 page for a static website bucket
    // String notFoundPage = "404.html";

    Storage storage = StorageOptions.newBuilder().setProjectId(projectId).build().getService();
    Bucket bucket = storage.get(bucketName);
    bucket.toBuilder().setIndexPage(indexPage).setNotFoundPage(notFoundPage).build().update();

    System.out.println(
        "Static website bucket "
            + bucketName
            + " is set up to use "
            + indexPage
            + " as the index page and "
            + notFoundPage
            + " as the 404 page");
  }
}

Node.js

Para mais informações, consulte a documentação de referência da API Cloud Storage Node.js.

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// The ID of your GCS bucket
// const bucketName = 'your-unique-bucket-name';

// The name of the main page
// const mainPageSuffix = 'http://example.com';

// The Name of a 404 page
// const notFoundPage = 'http://example.com/404.html';

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

async function addBucketWebsiteConfiguration() {
  await storage.bucket(bucketName).setMetadata({
    website: {
      mainPageSuffix,
      notFoundPage,
    },
  });

  console.log(
    `Static website bucket ${bucketName} is set up to use ${mainPageSuffix} as the index page and ${notFoundPage} as the 404 page`
  );
}

addBucketWebsiteConfiguration().catch(console.error);

PHP

Para mais informações, consulte a documentação de referência da API Cloud Storage PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Update the given bucket's website configuration.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 *        (e.g. 'my-bucket')
 * @param string $indexPageObject the name of an object in the bucket to use as
 *        (e.g. 'index.html')
 *     an index page for a static website bucket.
 * @param string $notFoundPageObject the name of an object in the bucket to use
 *        (e.g. '404.html')
 *     as the 404 Not Found page.
 */
function define_bucket_website_configuration(string $bucketName, string $indexPageObject, string $notFoundPageObject): void
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);

    $bucket->update([
        'website' => [
            'mainPageSuffix' => $indexPageObject,
            'notFoundPage' => $notFoundPageObject
        ]
    ]);

    printf(
        'Static website bucket %s is set up to use %s as the index page and %s as the 404 page.',
        $bucketName,
        $indexPageObject,
        $notFoundPageObject
    );
}

Python

Para mais informações, consulte a documentação de referência da API Cloud Storage Python.

from google.cloud import storage

def define_bucket_website_configuration(bucket_name, main_page_suffix, not_found_page):
    """Configure website-related properties of bucket"""
    # bucket_name = "your-bucket-name"
    # main_page_suffix = "index.html"
    # not_found_page = "404.html"

    storage_client = storage.Client()

    bucket = storage_client.get_bucket(bucket_name)
    bucket.configure_website(main_page_suffix, not_found_page)
    bucket.patch()

    print(
        "Static website bucket {} is set up to use {} as the index page and {} as the 404 page".format(
            bucket.name, main_page_suffix, not_found_page
        )
    )
    return bucket

Ruby

Para mais informações, consulte a documentação de referência da API Cloud Storage Ruby.

def define_bucket_website_configuration bucket_name:, main_page_suffix:, not_found_page:
  # The ID of your static website bucket
  # bucket_name = "www.example.com"

  # The index page for a static website bucket
  # main_page_suffix = "index.html"

  # The 404 page for a static website bucket
  # not_found_page = "404.html"

  require "google/cloud/storage"

  storage = Google::Cloud::Storage.new
  bucket = storage.bucket bucket_name

  bucket.update do |b|
    b.website_main = main_page_suffix
    b.website_404 = not_found_page
  end

  puts "Static website bucket #{bucket_name} is set up to use #{main_page_suffix} as the index page and " \
       "#{not_found_page} as the 404 page"
end

APIs REST

API JSON

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Crie um arquivo JSON que defina as propriedades mainPageSuffix e notFoundPage em um objeto website para as páginas desejadas:

    {
      "website":{
        "mainPageSuffix": "index.html",
        "notFoundPage": "404.html"
      }
    }
  3. Use cURL para chamar a API JSON com uma solicitação de bucket PATCH. Para o bucket my-static-assets:

    curl -X PATCH --data-binary @web-config.json \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      -H "Content-Type: application/json" \
      "https://storage.googleapis.com/storage/v1/b/my-static-assets"

API XML

  1. Receba um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth. Para ver instruções, consulte Autenticação de APIs.
  2. Crie um arquivo XML que defina os elementos MainPageSuffix e NotFoundPage em um elemento WebsiteConfiguration para as páginas desejadas:

    <WebsiteConfiguration>
      <MainPageSuffix>index.html</MainPageSuffix>
      <NotFoundPage>404.html</NotFoundPage>
    </WebsiteConfiguration>
  3. Use cURL (em inglês) para chamar a API XML com uma solicitação do bucket PUT e o parâmetro de string de consulta websiteConfig. Para my-static-assets:

    curl -X PUT --data-binary @web-config.xml \
      -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
      https://storage.googleapis.com/my-static-assets?websiteConfig

Configurar o balanceador de carga e o certificado SSL

Para que o Cloud Storage seja compatível com domínios personalizados que usam HTTPS, você precisa configurar um certificado SSL anexado a um balanceador de carga HTTPS para exibir seu site com esse protocolo. Nesta seção, mostraremos como adicionar seu bucket ao back-end de um balanceador de carga e como adicionar um novo certificado SSL gerenciado pelo Google ao front-end do balanceador de carga.

  1. Acesse a página Balanceamento de carga no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"
  2. Em Balanceamento de carga HTTP(S), clique em Iniciar configuração.
  3. Selecione Da Internet para VMs ou serviços sem servidor.
  4. Selecione Balanceador de carga HTTP(S) global.
  5. Clique em Continuar.

    A janela de configuração do balanceador de carga é exibida.

  6. Antes de continuar com a configuração, dê um nome ao balanceador de carga, como example-lb.

Configure o front-end

Nesta seção, mostraremos como configurar o protocolo HTTPS e criar um certificado SSL. Também é possível selecionar um certificado existente ou fazer o upload de um certificado SSL autogerenciado.

  1. Clique em Configuração de front-end.
  2. (Opcional) Atribua um Nome à configuração de front-end.
  3. Em Protocolo, selecione HTTPS (inclui HTTP/2).
  4. Em Versão IP, selecione IPv4. Se você preferir o IPv6, consulte Encerramento do IPv6 para mais informações.
  5. Para o campo Endereço IP:

    • Na lista suspensa, clique em Criar endereço IP.
    • No pop-up Reservar um novo endereço IP estático, insira um nome, como example-ip, para o Nome do endereço IP.
    • Clique em Reservar.
  6. Em Porta, selecione 443.

  7. No menu suspenso do campo Certificado, selecione Criar um novo certificado. O formulário de criação de certificado é exibido em um painel. Faça as configurações a seguir:

    • Dê um nome ao seu certificado, como example-ssl.
    • Em Modo de criação, selecione Criar certificado gerenciado pelo Google.
    • Em Domínios, insira o nome do seu site, como www.example.com. Se você quiser exibir seu conteúdo por meio de domínios adicionais, como o domínio raiz example.com, pressione Enter para incluí-lo em outras linhas. Cada certificado tem um limite de 100 domínios.
  8. Clique em Criar.

  9. (Opcional) Se você quiser que o Google Cloud configure automaticamente um balanceador de carga HTTP parcial para redirecionar tráfego HTTP, marque a caixa de seleção ao lado de Ativar redirecionamento HTTP para HTTPS.

  10. Clique em Concluído.

Configure o back-end

  1. Clique em Configuração de back-end.
  2. Na lista suspensa Serviços e buckets de back-end, clique em Criar um bucket de back-end.
  3. Escolha um nome do bucket de back-end, como example-bucket. O nome escolhido pode ser diferente do nome do bucket criado anteriormente.
  4. Clique em Procurar no campo Bucket do Cloud Storage.
  5. Selecione o bucket my-static-assets criado anteriormente e clique em Selecionar.
  6. (Opcional) Se você quiser usar o Cloud CDN, marque a caixa de seleção Ativar o Cloud CDN e configure o Cloud CDN como quiser. O Cloud CDN pode gerar custos adicionais.
  7. Clique em Criar.

Configurar regras de roteamento

As regras de roteamento são os componentes do mapa de URLs de um balanceador de carga HTTP(S) externo. Neste tutorial, pule esta parte da configuração do balanceador de carga, porque ela é configurada automaticamente para usar o back-end que acabou de configurar.

Analise a configuração

  1. Clique em Analisar e finalizar.
  2. Revise Front-end, Regras de roteamento e Back-end.
  3. Clique em Criar.

Pode ser necessário aguardar alguns minutos para que o balanceador de carga seja criado.

Como conectar seu domínio ao balanceador de carga

Depois que o balanceador de carga for criado, clique no nome: example-lb. Anote o endereço IP associado ao balanceador de carga: por exemplo, 30.90.80.100. Para apontar seu domínio para o balanceador de carga, crie um registro A usando o serviço de registro de domínio. Se você tiver adicionado vários domínios ao seu certificado SSL, será necessário adicionar um registro A para cada um deles, todos apontando para o endereço IP do balanceador de carga. Por exemplo, para criar registros A para www.example.com e example.com:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se você estiver usando o Google Domains, consulte a página de Ajuda do Google Domains para ver mais informações.

O Google Cloud pode levar de 60 a 90 minutos para provisionar o certificado e disponibilizar o site por meio do balanceador de carga. Para monitorar o status do seu certificado:

Console

  1. Acesse a página Balanceamento de carga no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"
  2. Clique no nome do balanceador de carga: example-lb.
  3. Clique no nome do certificado SSL associado ao balanceador de carga: example-ssl.
  4. As linhas Status e Status do domínio mostram o status do certificado. Ambos precisam estar ativos para que o certificado seja válido para seu site.

gcloud

  1. Para verificar o status do certificado, execute o comando a seguir:

    gcloud beta compute ssl-certificates describe CERTIFICATE_NAME \
      --global \
      --format="get(name,managed.status)"
    
  2. Para verificar o status do domínio, execute o comando a seguir:

    gcloud beta compute ssl-certificates describe CERTIFICATE_NAME \
      --global \
      --format="get(managed.domainStatus)"
    

Consulte Solução de problemas de certificados SSL para mais informações sobre o status do certificado.

Teste o site

Depois que o certificado SSL estiver ativo, verifique se o conteúdo é exibido a partir do bucket acessando https://www.example.com/test.html, em que test.html é um objeto armazenado no bucket que você está usando como back-end. Se você definir a propriedade MainPageSuffix, https://www.example.com será direcionado para index.html.

Limpar

Depois de concluir o tutorial, você pode limpar os recursos que criou para que eles parem de usar a cota e gerar cobranças. Nas seções a seguir, você aprenderá a excluir e desativar esses recursos.

Exclua o projeto

O jeito mais fácil de evitar cobranças é excluir o projeto que você criou para o tutorial.

Para excluir o projeto:

  1. No Console do Google Cloud, acesse a página Gerenciar recursos.

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

Excluir o balanceador de carga e o bucket

Se você não quiser excluir todo o projeto, exclua o balanceador de carga e o bucket que criou para o tutorial:

  1. Acesse a página Balanceamento de carga no Console do Google Cloud.
    Acessar a página "Balanceamento de carga"
  2. Marque a caixa de seleção ao lado de example-lb.
  3. Clique em Excluir.
  4. (Opcional) Marque a caixa de seleção ao lado dos recursos que você quer excluir com o balanceador de carga, como o bucketmy-static-assets ou o certificado SSL example-ssl.
  5. Clique em Excluir balanceador de carga ou Excluir balanceador de carga e os recursos selecionados.

Liberar um endereço IP reservado

Para excluir o endereço IP reservado usado no tutorial:

  1. No console do Google Cloud, acesse a página Endereços IP externos.

    Acessar Endereços IP externos

  2. Marque as caixas de seleção ao lado de example-ip.

  3. Clique em Liberar endereço estático.

  4. Na janela de confirmação, clique em Excluir.

A seguir

Faça um teste

Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho do Cloud Storage em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

Faça uma avaliação gratuita do Cloud Storage