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, como scripts do servidor, como PHP.

Este tutorial usa o Cloud Storage com balanceamento de carga HTTP(S) para disponibilizar 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. 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 as dicas na seção Monitorar suas cobranças para mais detalhes sobre as cobranças incorridas na hospedagem de um site estático. Consulte a página Preços para mais detalhes sobre os custos do Cloud Storage.

Antes de começar

1. Faça login na sua conta do Google.

   Se você ainda não tiver uma, inscreva-se.

2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do 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 a página do seletor de projetos

3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu 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. Confirme que você é proprietário ou administrador do 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.

6. 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).
7. Você precisa ter um papel de proprietário ou editor do projeto ou os seguintes papéis do Cloud Identity and Access Management: Administrador de objetos do Storage e Administrador de rede.

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 chamado www.example.com:

Console

1. Abra o navegador do Cloud Storage no Console do Google Cloud.
   Abrir o navegador do Cloud Storage

2. Clique em Criar bucket para abrir o formulário de criação do bucket.

3. Insira as informações do bucket e clique em Continuar para concluir cada etapa:

   • Defina o Nome do seu bucket. Recomendamos que ele seja igual ao seu nome de domínio para facilitar uma das pr´ximas etapas. Por exemplo, www.example.com.

   • Selecione o Tipo de local e o Local do seu bucket. Por exemplo, Região e us-east1.

   • Selecione Armazenamento padrão para Classe de armazenamento.

   • Selecione Uniforme para Controle de acesso.

4. Clique em Criar.

Se funcionar, a página Detalhes do bucket será aberta e exibirá o texto "Não há objetos ativos neste intervalo".

Consulte a Solução de problemas para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage.

gsutil

Use o comando gsutil mb:

gsutil mb -b on gs://www.example.com

Se funcionar, o comando retornará:

Creating gs://www.example.com/...

Amostras de código

C++

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

Ver no GitHub (em inglês) Feedback

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

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

Ver no GitHub (em inglês) Feedback

public static Bucket StorageCreateBucket(string projectId, string bucketName)
{
    var storage = StorageClient.Create();
    var bucket = storage.CreateBucket(projectId, bucketName);
    Console.WriteLine($"Created {bucketName}.");
    return bucket;
}

Go

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

Ver no GitHub (em inglês) Feedback

ctx := context.Background()
bucket := client.Bucket(bucketName)

ctx, cancel := context.WithTimeout(ctx, time.Second*10)
defer cancel()
if err := bucket.Create(ctx, projectID, &storage.BucketAttrs{
	StorageClass: "COLDLINE",
	Location:     "asia",
}); err != nil {
	return err
}

Java

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

Ver no GitHub (em inglês) 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 do Cloud Storage para Node.js.

Ver no GitHub (em inglês) Feedback

/**
 * TODO(developer): Uncomment the following line before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';

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

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

async function createBucket() {
  // Creates a new bucket in the Asia region with the coldline default storage
  // class. Leave the second argument blank for default settings.
  //
  // 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: 'ASIA',
    storageClass: 'COLDLINE',
  });

  console.log(`Bucket ${bucket.name} created.`);
}

createBucket().catch(console.error);

PHP

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

Ver no GitHub (em inglês) Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Create a Cloud Storage Bucket.
 *
 * @param string $bucketName name of the bucket to create.
 * @param string $options options for the new bucket.
 *
 */
function create_bucket($bucketName, $options = [])
{
    $storage = new StorageClient();
    $bucket = $storage->createBucket($bucketName, $options);
    printf('Bucket created: %s' . PHP_EOL, $bucket->name());
}

Python

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

Ver no GitHub (em inglês) Feedback

from google.cloud import storage

def create_bucket(bucket_name):
    """Creates a new bucket."""
    # bucket_name = "your-new-bucket-name"

    storage_client = storage.Client()

    bucket = storage_client.create_bucket(bucket_name)

    print("Bucket {} created".format(bucket.name))

Ruby

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

Ver no GitHub (em inglês) Feedback

# bucket_name   = "Name of Google Cloud Storage bucket to create"
# location      = "Location of where to create Cloud Storage bucket"
# storage_class = "Storage class of Cloud Storage bucket"

require "google/cloud/storage"

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

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

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.

2. Crie um arquivo .json que atribua o nome do seu site à propriedade name:

   {
     "name": "www.example.com"
   }

3. Use cURL para chamar a API JSON. No caso de www.example.com:

   curl -X POST --data-binary @website-bucket-name.json \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "Content-Type: application/json" \
     "https://storage.googleapis.com/storage/v1/b?project=my-static-website"

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.

2. Use cURL para chamar a API XML para criar um bucket com o nome do seu site. No caso de www.example.com:

   curl -X PUT \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "x-goog-project-id: my-static-website" \
     "https://storage.googleapis.com/www.example.com"

Como fazer o upload dos arquivos do seu site

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

Console

1. Abra o navegador do Cloud Storage no Console do Google Cloud.
   Abrir o navegador do Cloud Storage

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

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

Consulte a Solução de problemas para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage.

gsutil

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

gsutil cp Desktop/index.html gs://www.example.com

Se funcionar, o comando retornará:

Copying file://Desktop/index.html [Content-Type=text/html]...
Uploading   gs://www.example.com/index.html:       0 B/2.58 KiB
Uploading   gs://www.example.com/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++.

Ver no GitHub (em inglês) 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 do Cloud Storage para C#.

Ver no GitHub (em inglês) Feedback

private void UploadFile(string bucketName, string localPath,
    string objectName = null)
{
    var storage = StorageClient.Create();
    using (var f = File.OpenRead(localPath))
    {
        objectName = objectName ?? Path.GetFileName(localPath);
        storage.UploadObject(bucketName, objectName, null, f);
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

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

Ver no GitHub (em inglês) 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.

Ver no GitHub (em inglês) 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 do Cloud Storage para Node.js.

Ver no GitHub (em inglês) Feedback

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const filename = 'Local file to upload, e.g. ./local/path/to/file.txt';

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

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

async function uploadFile() {
  // Uploads a local file to the bucket
  await storage.bucket(bucketName).upload(filename, {
    // Support for HTTP requests made with `Accept-Encoding: gzip`
    gzip: true,
    // By setting the option `destination`, you can change the name of the
    // object you are uploading to a bucket.
    metadata: {
      // Enable long-lived HTTP caching headers
      // Use only if the contents of the file will never change
      // (If the contents will change, use cacheControl: 'no-cache')
      cacheControl: 'public, max-age=31536000',
    },
  });

  console.log(`${filename} uploaded to ${bucketName}.`);
}

uploadFile().catch(console.error);

PHP

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

Ver no GitHub (em inglês) Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Upload a file.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of the object.
 * @param string $source the path to the file to upload.
 *
 * @return Psr\Http\Message\StreamInterface
 */
function upload_object($bucketName, $objectName, $source)
{
    $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 do Cloud Storage para Python.

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

Ver no GitHub (em inglês) Feedback

from google.cloud import storage

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    # bucket_name = "your-bucket-name"
    # source_file_name = "local/path/to/file"
    # 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.

Ver no GitHub (em inglês) Feedback

# bucket_name       = "Your Google Cloud Storage bucket name"
# local_file_path   = "Path to local file to upload"
# storage_file_path = "Path to store the file in Google Cloud Storage"

require "google/cloud/storage"

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

file = bucket.create_file local_file_path, storage_file_path

puts "Uploaded #{file.name}"

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.

2. Use cURL para chamar a API JSON com uma solicitação de POST Objeto. Para a página de índice de www.example.com:

   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/www.example.com/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.

2. Use cURL para chamar a API XML com uma solicitação de PUT Objeto. Para a página de índice de www.example.com:

   curl -X PUT --data-binary @index.html \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     -H "Content-Type: text/html" \
     "https://storage.googleapis.com/www.example.com/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, use:

gsutil rsync -R local-dir gs://www.example.com

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. Abra o navegador do Cloud Storage no Console do Google Cloud.
   Abrir o navegador do Cloud Storage

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.

Consulte a Solução de problemas para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage.

gsutil

Use o comando gsutil iam ch:

gsutil iam ch allUsers:objectViewer gs://www.example.com

Amostras de código

C++

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

Ver no GitHub (em inglês) Feedback

namespace gcs = google::cloud::storage;
using google::cloud::StatusOr;
[](gcs::Client client, std::string const& bucket_name) {
  StatusOr<google::cloud::IamPolicy> current_policy =
      client.GetBucketIamPolicy(bucket_name);

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

  current_policy->bindings.AddMember("roles/storage.objectViewer",
                                     "allUsers");

  // Update the policy. Note the use of `gcs::IfMatchEtag` to implement
  // optimistic concurrency control.
  StatusOr<google::cloud::IamPolicy> updated_policy =
      client.SetBucketIamPolicy(bucket_name, *current_policy,
                                gcs::IfMatchEtag(current_policy->etag));

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

  auto role = updated_policy->bindings.find("roles/storage.objectViewer");
  if (role == updated_policy->bindings.end()) {
    std::cout << "Cannot find 'roles/storage.objectViewer' in the updated"
              << " policy. This can happen if another application updates"
              << " the IAM policy at the same time. Please retry the"
              << " operation.\n";
    return;
  }
  auto member = role->second.find("allUsers");
  if (member == role->second.end()) {
    std::cout << "'allUsers' is not a member of the"
              << " 'roles/storage.objectViewer' role in the updated"
              << " policy. This can happen if another application updates"
              << " the IAM policy at the same time. Please retry the"
              << " operation.\n";
    return;
  }
  std::cout << "IamPolicy successfully updated for bucket " << bucket_name
            << '\n';
}

Java

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

Ver no GitHub (em inglês) 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");
  }
}

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.

2. Crie um arquivo .json com as informações a seguir:

   {
     "bindings":[
       {
         "role": "roles/storage.objectViewer",
         "members":["allUsers"]
       }
     ]
   }

3. Use cURL (em inglês) para chamar a API JSON com uma solicitação PUT Bucket:

   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"

   Onde:

   • [JSON_FILE_NAME] é o nome do arquivo que você criou na Etapa 2.
   • [OAUTH2_TOKEN] é o token de acesso que você criou na Etapa 1;
   • [BUCKET_NAME] é o nome do bucket que contém os objetos você quer tornar públicos. Por exemplo, my-bucket.

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][13].

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. Abra o navegador do Cloud Storage no Console do Google Cloud.
   Abrir o navegador do Cloud Storage

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.

   Observação: esta opção só está disponível para buckets com nome correspondente a um padrão válido de site. Se o nome do bucket não corresponder ao padrão do site, use a gsutil.

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 .

.

Consulte a Solução de problemas para informações detalhadas sobre erros de operações com falha no navegador do Cloud Storage.

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://www.example.com

Se funcionar, o comando retornará:

Setting website config on gs://www.example.com/...

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

Ver no GitHub (em inglês) 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";
}

Java

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

Ver no GitHub (em inglês) 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");
  }
}

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.

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 PATCH bucket. No caso de www.example.com:

   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/www.example.com"

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.

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 para chamar a API XML com uma solicitação de PUT bucket e parâmetro de string de consulta de websiteConfig. Para www.example.com:

   curl -X PUT --data-binary @web-config.xml \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     https://storage.googleapis.com/www.example.com?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 veicular seu site por HTTPS, é necessário um certificado SSL. Esta seção mostra 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 do 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 www.example.com e clique em Selecionar.
6. 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

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, veja mais informações em Criar um registro A ou CNAME.

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

Quando o certificado SSL estiver ativo, verifique se o conteúdo é veiculado do bucket acessando https://www.example.com/test.html, em que test.html é um objeto armazenado em um bucket chamado www.example.com. Se você definir a propriedade MainPageSuffix, https://www.example.com é direcionado para index.html.

Observação: para redirecionar o tráfego de HTTP para HTTPS, você precisa configurar um balanceador de carga HTTP adicional 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.

Limpar

Depois de concluir o tutorial "Hospedagem de um site estático", limpe os recursos criados no Google Cloud para que eles não ocupem cota e não sejam cobrados no futuro. Veja como excluir e desativar esses recursos nas seções a seguir.

Como 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 a página "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 bucketwww.example.com 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 bukets.

A seguir

• Saiba como exibir seu site estático por HTTP.
• Veja exemplos e dicas para usar buckets para hospedar um site estático.
• Acesse 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.