Como hospedar um site estático

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 (scripts do servidor, por exemplo) 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 conhecer mais formas de exibir conteúdo de um domínio personalizado por HTTPS, consulte o tópico de solução de problemas relacionado. 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.

Cuidado: este tutorial disponibiliza o conteúdo para a Internet pública. Recomendamos que você não exiba conteúdo com dados confidenciais ou particulares do seu bucket do Cloud Storage.

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:

• Cloud Storage
• Cloud Load Balancing

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.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

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

4. 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.

   Este tutorial usa o domínio example.com.

5. 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).
6. Tenha os seguintes papéis do Identity and Access Management: Administrador de objetos do Storage e Administrador de rede
7. (Opcional) É possível atribuir ao bucket do Cloud Storage o mesmo nome do domínio. Para fazer isso, é preciso verificar se você tem ou gerencia o domínio que será usado. 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.

   Observação: se você é proprietário do domínio que está associado a um bucket, talvez já tenha realizado esta etapa anteriormente. Se você comprou seu domínio pelo Google Domains, a confirmação será automática.

Observação: para informações sobre como usar o Cloud DNS para configurar seu domínio, consulte Configurar seu domínio usando o Cloud DNS.

Criar um bucket

Para criar um bucket:

Console

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

   Acessar o navegador

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 nomenclatura de bucket.
   • Por Escolha onde armazenar seus dados, selecione um Tipo de local e a Localização onde os dados do bucket serão armazenados permanentemente.
   • Em Escolha uma classe de armazenamento padrão para os dados, selecione uma classe de armazenamento para o bucket. A classe de armazenamento padrão é atribuída por padrão a todos os objetos carregados no 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 Escolher como controlar o acesso a objetos, selecione se o bucket aplicará ou não a prevenção de acesso público e selecione 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 será bloqueada.

   • Para Configurações avançadas (opcional), adicione rótulos de intervalos, defina uma política de retenção e escolha um método de criptografia.
4. Clique em Criar.

Para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage, consulte Solução de problemas.

gsutil

Use o comando gsutil mb:

gsutil mb gs://BUCKET_NAME

Em que:

• BUCKET_NAME é o nome que você quer dar ao bucket, sujeito a requisitos de nomenclatura. Por exemplo, my-bucket.

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 projeto ao qual o 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: ative o acesso uniforme no nível do bucket para seu bucket.

Exemplo:

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

Amostras de código

Observação: outras opções para criar um novo bucket podem ser encontradas na referência da API JSON para bucket.insert

C++

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

Veja no GitHub Feedback

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 para C#.

Veja no GitHub Feedback

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 para Go.

Veja no GitHub Feedback

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*10)
	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 para Java.

Veja no GitHub Feedback

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 para Node.js.

Veja no GitHub Feedback

/**
 * 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/bucket-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 para PHP.

Veja no GitHub Feedback

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.
 */
function create_bucket_class_location($bucketName)
{
    // $bucketName = 'my-bucket';

    $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 para Python.

Veja no GitHub Feedback

from google.cloud import storage

def create_bucket_class_location(bucket_name):
    """Create a new bucket in specific location with 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 para Ruby.

Ver no GitHub Feedback

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

APIs REST

API JSON

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.
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:

{
  "name": "BUCKET_NAME",
  "location": "BUCKET_LOCATION",
  "storageClass": "STORAGE_CLASS",
  "iamConfiguration": {
    "uniformBucketLevelAccess": {
      "enabled": true
    },
  }
}

Em que:

• BUCKET_NAME é o nome que você quer dar ao bucket, sujeito a requisitos de nomenclatura. Por exemplo, my-bucket.
• BUCKET_LOCATION é o local em que você quer armazenar os dados de objeto do intervalo. Por exemplo, US-EAST1.
• STORAGE_CLASS é a classe de armazenamento padrão do bucket. Por exemplo, NEARLINE.
3. 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_ID"

   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_ID é o ID do projeto ao qual o bucket será associado. Por exemplo, my-project.

API XML

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.
2. Crie um arquivo .xml com as informações a seguir:

<CreateBucketConfiguration>
   <LocationConstraint>BUCKET_LOCATION</LocationConstraint>
   <StorageClass>STORAGE_CLASS</StorageClass>
</CreateBucketConfiguration>

Em que:

• BUCKET_LOCATION é o local em que você quer armazenar os dados de objeto do intervalo. Por exemplo, US-EAST1.
• STORAGE_CLASS é a classe de armazenamento padrão do bucket. Por exemplo, NEARLINE.
3. 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.

Como fazer o 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 Navegador do Cloud Storage.
   

   Acessar o navegador

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

   A página Detalhes do bucket será 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 pretendido.

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

Para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage, 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 para C++.

Veja no GitHub Feedback

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 para C#.

Veja no GitHub Feedback

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 para Go.

Veja no GitHub Feedback

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

	// Upload an object with storage.Writer.
	wc := client.Bucket(bucket).Object(object).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 para Java.

Veja no GitHub Feedback

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"

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

    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 para Node.js.

Para mais informações sobre como fazer upload de um stream, string ou buffer, consulte File.save().

Ver no GitHub Feedback

/**
 * 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() {
  await storage.bucket(bucketName).upload(filePath, {
    destination: destFileName,
  });

  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 para PHP.

Veja no GitHub Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName The name of your Cloud Storage bucket.
 * @param string $objectName The name of your Cloud Storage object.
 * @param string $source The path to the file to upload.
 */
function upload_object($bucketName, $objectName, $source)
{
    // $bucketName = 'my-bucket';
    // $objectName = 'my-object';
    // $source = '/path/to/your/file';

    $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 para Python.

Use o método Blob.upload_from_file(), Blob.upload_from_filename() ou Blob.upload_from_string() para fazer upload de um objeto.

Ver no GitHub Feedback

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(
        "File {} uploaded to {}.".format(
            source_file_name, destination_blob_name
        )
    )

Ruby

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

Veja no GitHub Feedback

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

  file = bucket.create_file local_file_path, file_name

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

APIs REST

API JSON

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

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. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

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"

Observação: se você estiver migrando um site existente ou copiando um grande número de arquivos, use gsutil rsync para mover seu conteúdo. Você pode usar a opção -R para copiar as árvores de diretórios de modo recursivo. Por exemplo, para sincronizar um diretório local denominado local-dir com um bucket denominado my-static-assets, use:

gsutil rsync -R local-dir gs://my-static-assets

Como compartilhar arquivos

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

Cuidado: antes de tornar seu bucket acessível publicamente, verifique se os arquivos contidos nele não contêm informações confidenciais ou particulares.

Console

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

   Acessar o navegador

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

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

4. Clique no botão Adicionar membros.

   A caixa de diálogo Adicionar membros é exibida.

5. No campo Novos membros, insira allUsers.

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

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 neste ícone para ver o URL do objeto.

Para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage, 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 para C++.

Veja no GitHub Feedback

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 para Go.

Veja no GitHub Feedback

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 para Java.

Veja no GitHub Feedback

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 para Node.js.

Ver no GitHub Feedback

/**
 * 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 para Python.

Veja no GitHub Feedback

from google.cloud import storage

def set_bucket_public_iam(bucket_name):
    """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": {"allUsers"}}
    )

    bucket.set_iam_policy(policy)

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

Ruby

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

Veja no GitHub Feedback

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

APIs REST

API JSON

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

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.json \
     -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 nome do arquivo que você criou 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.

Observação: roles/storage.objectViewer inclui permissão para listar os objetos no bucket. Se você não quiser conceder a listagem publicamente, use roles/storage.legacyObjectReader.

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: como 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 Navegador do Cloud Storage.
   

   Acessar o navegador

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.

Observação: essas configurações podem ser visualizadas, alteradas ou removidas no menu Editar configuração de site.

.

Para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage, 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/...

Observação: Altere ou remova estas configurações com comandos gsutil web set adicionais e veja essas configurações com o comando gsutil web get.

Amostras de código

C++

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

Veja no GitHub Feedback

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";
}

Go

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

Veja no GitHub Feedback

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 para Java.

Veja no GitHub Feedback

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 para Node.js.

Veja no GitHub Feedback

/**
 * 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 para PHP.

Veja no GitHub Feedback

use Google\Cloud\Storage\StorageClient;

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

    $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 para Python.

Veja no GitHub Feedback

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 para Ruby.

Veja no GitHub Feedback

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. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

2. Crie um arquivo .json que defina as propriedades de 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. Consiga um token de acesso de autorização do OAuth 2.0 Playground (em inglês). Configure o Playground para usar suas credenciais do OAuth.

2. Crie um arquivo .xml que defina os elementos de 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

Observação: use outras solicitações PUT para alterar ou remover essas configurações e use uma solicitação GET para vê-las.

Como 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 minhas VMs e clique em Continuar.
4. Dê um Nome ao balanceador de carga, como example-lb.

Como configurar o back-end

1. Clique em Configuração de back-end.
2. Na lista suspensa, clique em Criar ou selecionar serviços e buckets de back-end, acesse o submenu Buckets de back-end e selecione a opção Criar um bucket de back-end.
3. Escolha um Nome para o bucket de back-end, como example-bucket.
4. Clique em Procurar em Bucket do Cloud Storage.
5. Selecione o bucket my-static-assets e clique em Selecionar.
6. Se você quiser usar o Cloud CDN, marque a caixa de seleção Ativar Cloud CDN. Deixe a Seleção de modo de cache como Conteúdo estático do cache. O Cloud CDN pode gerar custos adicionais.
7. Clique em Criar.

Como configurar regras de host e correspondentes de caminho

As regras de host e os correspondentes de caminho são componentes de configuração do Mapa de URLs de um balanceador de carga de HTTP(S) externo.

1. Clique em Regras de host e caminho.
2. Deixe o Modo na regra de host e caminho simples padrão do bucket de back-end example-bucket, criado anteriormente.

Como configurar 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. Configure os valores dos campos a seguir:

   • Protocolo: HTTPS
   • Nível de serviço de rede: Premium
   • Versão IP: IPv4. Se você preferir o IPv6, consulte Encerramento do IPv6 para mais informações.

3. Para o campo Endereço IP:

   1. Na lista suspensa, clique em Criar endereço IP.
   2. No pop-up, selecione Reservar um novo endereço IP estático, digite example-ip como o Nome do endereço.
   3. Clique em Reservar.
   Observação: reservar um novo endereço IP estático gera custos adicionais se o endereço IP não estiver anexado a um regra de encaminhamento. Para evitar esses custos, exclua o endereço IP estático ao excluir o balanceador de carga associado.

4. Em Porta, selecione 443.

5. No 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:

   • Nome: example-ssl
   • Modo de criação: crie um certificado gerenciado pelo Google
   • Domínios: 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.

6. Clique em Criar.

7. Clique em Concluído.

Como verificar a configuração

1. Clique em Analisar e finalizar.
2. Verifique a Configuração de back-end, as Regras de host e caminho e a Configuração de front-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ê adicionou vários domínios ao certificado SSL, adicione 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.

Recomendado: como monitorar o status do certificado SSL

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.

Como testar 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.

Observação: para redirecionar o tráfego de HTTP para HTTPS, você precisa configurar mais um balanceador de carga HTTP com uma configuração de redirecionamento no mapa de URL. Veja instruções em Como configurar o redirecionamento HTTP para HTTPS em balanceadores de carga HTTP(S) externos.

Limpeza

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.

Excluir o projeto

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

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para seguir este tutorial, a exclusão dele incluirá quaisquer outras ações feitas no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar vários tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do 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.

Como 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.

Observação: se você quiser excluir apenas o bucket criado, siga as instruções em Como excluir buckets.

Como liberar um endereço IP reservado

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

1. No Console do 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

• Saiba como exibir seu site estático por HTTP.
• Veja exemplos e dicas sobre como usar buckets para hospedar um site estático.
• Veja a seção de solução de problemas para hospedar um site estático.
• Saiba mais sobre hospedagem de recursos estáticos em um site dinâmico.
• Conheça outras soluções de exibição da Web do Google Cloud.
• Teste outros tutoriais do Google Cloud que usam o Cloud Storage.

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 recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

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