Como hospedar um site estático

Neste tutorial, descrevemos como configurar um intervalo 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. Elas não podem ter conteúdo dinâmico, como scripts de servidor (exemplo: PHP). Para saber mais sobre páginas da Web estáticas, com exemplos e dicas, consulte a página sobre sites estáticos.

Neste tutorial, também abordamos a hospedagem de recursos estáticos para um site dinâmico.

Cuidado: este tutorial está relacionado ao uso de HTTP. Recomendamos que você não exiba conteúdo com dados confidenciais ou particulares via HTTP a partir do seu intervalo do Cloud Storage. Para conhecer opções de exibição de conteúdo em um domínio personalizado por HTTPS, consulte o tópico de solução de problemas correspondente.

Objetivos

Neste tutorial, você aprenderá a:

• apontar seu domínio para o Cloud Storage usando um registro CNAME;
• criar um intervalo vinculado ao seu domínio;
• fazer o upload de arquivos do seu site e compartilhá-los;
• testar o site.

Custos

Neste tutorial, são usados os seguintes componentes faturáveis do Cloud Platform:

• Cloud Storage

Consulte as dicas na seção Como monitorar cobranças de armazenamento para mais detalhes sobre as cobranças ligadas à 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. Selecione ou crie um projeto do Google Cloud Platform.

   Observação: se você não pretende manter os recursos criados neste tutorial, crie um novo projeto em vez de selecionar um existente. Depois de terminar, é possível excluir o projeto, removendo todos os recursos associados ao projeto e ao tutorial.

   Acessar a página Gerenciar recursos

3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

   Saiba como ativar o faturamento

4. Tenha um domínio próprio ou que você gerencia. Se não tiver um domínio, há muitos serviços que podem ser usados para registrar um novo, como o Google Domains.

   Neste tutorial, usamos o domínio example.com.

5. Confirme que você é proprietário ou administrador do domínio que será usado. Realize a confirmação no domínio de nível mais alto, como example.com, não um subdomínio, como www.example.com.

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

Como criar um registro CNAME

Um registro CNAME é um tipo de registro DNS. Ele direciona o tráfego que solicita um URL do seu domínio para os recursos que você quer disponibilizar. Nesse caso, objetos nos seus intervalos do Cloud Storage. Com relação a www.example.com, o registro CNAME pode conter as seguintes informações:

NAME                  TYPE     DATA
www.example.com       CNAME    c.storage.googleapis.com.

Para mais informações sobre redirecionamentos CNAME, consulte URI para alias de CNAME.

Para conectar seu domínio ao Cloud Storage:

1. Crie um registro CNAME que aponte para c.storage.googleapis.com..

   Seu serviço de registro de domínio precisa permitir que você administre seu domínio, inclusive para adicionar um registro CNAME. Por exemplo, se você usa o Google Domains, consulte as instruções sobre como adicionar um registro CNAME na página Ajuda do Google Domains.

   Observação: dependendo do seu serviço de registro de domínio, só será possível usar registros CNAME para mapear para subdomínios, como www.example.com ou myblog.example.com, e não diretamente para o domínio raiz, example.com.

Como criar um intervalo

Crie um intervalo com o nome que corresponde ao CNAME criado para o domínio.

Por exemplo, se você adicionou um registro CNAME que aponta para www.example.com ou c.storage.googleapis.com., crie um intervalo com o nome "www.example.com".

Para criar um intervalo:

Console

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

2. Clique em Criar intervalo.

3. Na caixa de diálogo Criar intervalo, especifique:

   • O Nome do intervalo.

   • A Classe de armazenamento do intervalo: multirregional.

   • O local do intervalo: Estados Unidos.

4. Clique em Criar.

Se funcionar, você será direcionado para a página do intervalo com o texto "Não há objetos neste intervalo".

gsutil

Use o comando gsutil mb:

gsutil mb gs://www.example.com

Se for bem-sucedido, 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 do Cloud Storage para C++.

Ver no GitHub Feedback

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string 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 Cloud Storage para C#.

Ver no GitHub Feedback

private void CreateBucket(string bucketName)
{
    var storage = StorageClient.Create();
    storage.CreateBucket(s_projectId, bucketName);
    Console.WriteLine($"Created {bucketName}.");
}

Go

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

Ver no GitHub Feedback

bucket := client.Bucket(bucketName)
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 Feedback

Bucket bucket =
    storage.create(
        BucketInfo.newBuilder(bucketName)
            // See here for possible values: http://g.co/cloud/storage/docs/storage-classes
            .setStorageClass(StorageClass.COLDLINE)
            // Possible values: http://g.co/cloud/storage/docs/bucket-locations#location-mr
            .setLocation("asia")
            .build());

Node.js

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

Ver no GitHub Feedback

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

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

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

// 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
await storage.createBucket(bucketName, {
  location: 'ASIA',
  storageClass: 'COLDLINE',
});

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

PHP

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

Ver no GitHub 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.
 *
 * @return Google\Cloud\Storage\Bucket the newly created 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 Cloud Storage para Python.

Ver no GitHub Feedback

def create_bucket(bucket_name):
    """Creates a new bucket."""
    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 Feedback

# project_id    = "Your Google Cloud project ID"
# 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 project_id: project_id
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. Consiga 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 a propriedade name com o nome do seu site:

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

3. Use cURL (em inglês) 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://www.googleapis.com/storage/v1/b?project=my-static-website"

API XML

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
2. Use cURL (em inglês) para chamar a API XML e criar um intervalo 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

Para adicionar ao intervalo os arquivos que você quer que sejam disponibilizados pelo seu site:

Console

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

2. Na lista de intervalos, clique no nome do intervalo que você criou.

3. Clique no botão Fazer o upload dos arquivos na guia Objetos

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

Depois que o upload for concluído, serão exibidas as informações de nome, tamanho, tipo de arquivo e data da última modificação no intervalo.

Por exemplo, um intervalo com dois arquivos index.html e 404.html aparece no Console do GCP como:

Exemplo de um intervalo configurado como site.

gsutil

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

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

Se for bem-sucedido, 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 do Cloud Storage para C++.

Ver no GitHub Feedback

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

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

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

C#

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

Ver no GitHub 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 Feedback

f, err := os.Open("notes.txt")
if err != nil {
	return err
}
defer f.Close()

wc := client.Bucket(bucket).Object(object).NewWriter(ctx)
if _, err = io.Copy(wc, f); err != nil {
	return err
}
if err := wc.Close(); 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 Feedback

Storage storage = StorageOptions.getDefaultInstance().getService();
BlobId blobId = BlobId.of("bucket", "blob_name");
BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
Blob blob = storage.create(blobInfo, "Hello, Cloud Storage!".getBytes(UTF_8));

Node.js

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

Ver no GitHub Feedback

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

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

/**
 * 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';

// 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}.`);

PHP

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

Ver no GitHub 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 Cloud Storage para Python.

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

Ver no GitHub Feedback

def upload_blob(bucket_name, source_file_name, destination_blob_name):
    """Uploads a file to the bucket."""
    storage_client = storage.Client()
    bucket = storage_client.get_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 Feedback

# project_id        = "Your Google Cloud project ID"
# 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 project_id: project_id
bucket  = storage.bucket bucket_name

file = bucket.create_file local_file_path, storage_file_path

puts "Uploaded #{file.name}"

APIs REST

API JSON

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
2. Adicione os dados do arquivo ao corpo da solicitação.
3. Use cURL (em inglês) para chamar a API JSON com uma solicitação POST Object. No caso da 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://www.googleapis.com/upload/storage/v1/b/www.example.com/o?uploadType=media&name=index.html"

Consulte a página Como fazer um upload simples para mais informações sobre como fazer upload de objetos com a API JSON.

API XML

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
2. Adicione os dados do objeto ao corpo da solicitação.
3. Use cURL (em inglês) para chamar a API XML com uma solicitação PUT Object. No caso da 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: para migrar um site atual ou copiar um grande número de arquivos, use gsutil rsync para transferir o conteúdo. É possível usar a opção -R para copiar as árvores de diretórios maneira recursiva. Por exemplo, para sincronizar um diretório local chamado local-dir com um intervalo, use:

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

Como compartilhar arquivos

Você pode tornar todos os arquivos do seu intervalo acessíveis publicamente ou definir objetos individuais que possam ser acessados pelo seu site. Normalmente é mais fácil e rápido tornar todos os arquivos do seu intervalo acessíveis.

• Para tornar todos os arquivos acessíveis, siga o guia do Cloud Storage sobre como ativar a leitura pública de grupos de objetos.

• Para tornar arquivos individuais acessíveis, siga o guia do Cloud Storage sobre como ativar a leitura pública de objetos individuais.

Se você optar por controlar a acessibilidade de arquivos individuais, defina a ACL padrão de objetos para o intervalo. Assim, os próximos arquivos carregados no intervalo serão compartilhados por padrão.

Observação: os visitantes receberão um código de resposta http 403 quando solicitarem o URL de um arquivo que não é público ou é inexistente. Veja a próxima seção para saber como adicionar uma página de erro que usa um código de resposta http 404.

Recomendado: como atribuir páginas especiais

É possível atribuir um sufixo de página de índice (que é controlado pela propriedade MainPageSuffix) e uma página de erro personalizada (que é controlada pela propriedade NotFoundPage). Eles são opcionais. No entanto, se não houver página de índice, nada será exibido quando os usuários acessarem seu site de nível superior, por exemplo, http://www.example.com.

Páginas de índice

Uma página de índice (também chamada de índice de diretórios do servidor da Web) é um arquivo disponibilizado aos visitantes quando eles solicitam um URL sem arquivo associado. Quando você atribui um MainPageSuffix, o Cloud Storage procura um arquivo com esse nome e com o prefixo que corresponda ao URL solicitado pelo visitante.

Por exemplo, digamos que você definiu o MainPageSuffix do seu site estático como index.html. Além disso, vamos supor que você não tem nenhum arquivo chamado directory no intervalo www.example.com. Nessa situação, se um usuário solicitar o URL http://www.example.com/directory, o Cloud Storage tentará disponibilizar o arquivo www.example.com/directory/index.html. Caso esse arquivo também não exista, o Cloud Storage retornará uma página de erro.

O MainPageSuffix também controla o arquivo disponibilizado quando os usuários solicitam o site de nível superior. Continuando com o exemplo acima, se um usuário solicitar http://www.example.com, o Cloud Storage tentará disponibilizar o arquivo www.example.com/index.html.

Página de erro

A página de erro é o arquivo retornado aos visitantes do site que solicitarem um URL que não corresponde a um arquivo existente. Caso você tenha atribuído um MainPageSuffix, o Cloud Storage retornará a página de erro somente se não houver um arquivo com o nome solicitado nem uma página de índice aplicável.

Ao retornar uma página de erro, o código de resposta http é 404. A propriedade NotFoundPage controla qual arquivo funciona como página de erro. Caso a propriedade NotFoundPage não seja definida, os usuários receberão uma página de erro genérica.

Como definir MainPageSuffix e NotFoundPage

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

Console

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

2. Na lista de intervalos, encontre o intervalo que você criou.

3. Clique no ícone de mais ações ao lado do intervalo e selecione Editar configuração de site.

   Observação: essa opção está disponível apenas para intervalos com nomes que correspondem a um padrão de site válido.

4. Na caixa de diálogo Configurar site, especifique a Página principal e a Página 404 (não encontrada).

5. Clique em Salvar.

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

gsutil

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

gsutil web set -m index.html -e 404.html gs://www.example.com

Se for bem-sucedido, o comando retornará:

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

Observação: use os comandos gsutil web set adicionais para alterar ou remover essas configurações, e o comando gsutil web get para visualizá-las.

APIs REST

API JSON

1. Consiga 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 define as propriedades mainPageSuffix e notFoundPage em um objeto website para as páginas que você quer:

   {
   "website":{
   "mainPageSuffix": "index.html",
   "notFoundPage": "404.html"
   }
   }

3. Use cURL (em inglês) para chamar a API JSON com uma solicitação 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://www.googleapis.com/storage/v1/b/www.example.com"

API XML

1. Consiga 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 MainPageSuffix e NotFoundPage em um elemento WebsiteConfiguration para as páginas que você quer:

   <WebsiteConfiguration>
   <MainPageSuffix>index.html</MainPageSuffix>
   <NotFoundPage>404.html</NotFoundPage>
   </WebsiteConfiguration>

3. Use o cURL (em inglês) para chamar a API XML com uma solicitação PUT Bucket e com o parâmetro de string de consulta websiteConfig. No caso de 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 solicitações PUT adicionais para alterar ou remover essas configurações, e a solicitação GET para visualizá-las.

Como testar o site

Solicite o nome do domínio em um navegador para verificar se o conteúdo é disponibilizado pelo intervalo. Isso pode ser feito com um caminho para um objeto ou apenas com o nome de domínio, se você definir a propriedade MainPageSuffix.

Por exemplo, se você tiver um objeto chamado test.html armazenado em um intervalo chamado www.example.com, pode verificar se ele está acessível usando www.example.com/test.html no navegador.

Como limpar

Depois de concluir este tutorial, limpe os recursos criados no GCP para que eles não consumam cota e você não seja cobrado por eles 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 códigos 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 código 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 GCP, acesse a página "Projetos".

   Acessar a página Projetos

2. Na lista de projetos, selecione um e clique em Excluir projeto.
3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

Como excluir o intervalo

Caso não queira excluir o projeto inteiro, exclua o intervalo usado para hospedar seu site:

Console

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

2. Marque a caixa de seleção do intervalo que pretende excluir.

3. Clique em Excluir.

4. Na janela de sobreposição que aparece, clique em Excluir e confirme a exclusão do intervalo e do respectivo conteúdo.

gsutil

Use o comando gsutil rm com a sinalização -r para excluir o intervalo e o conteúdo dentro dele:

gsutil rm -r gs://www.example.com

A resposta terá esta aparência:

Removing gs://www.example.com/...

Amostras de código

C++

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

Ver no GitHub Feedback

namespace gcs = google::cloud::storage;
[](gcs::Client client, std::string bucket_name) {
  google::cloud::Status status = client.DeleteBucket(bucket_name);

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

  std::cout << "The bucket " << bucket_name << " was deleted successfully.\n";
}

C#

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

Ver no GitHub Feedback

private void DeleteBucket(string bucketName)
{
    var storage = StorageClient.Create();
    storage.DeleteBucket(bucketName);
    Console.WriteLine($"Deleted {bucketName}.");
}

Go

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

Ver no GitHub Feedback

if err := client.Bucket(bucketName).Delete(ctx); 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 Feedback

boolean deleted = bucket.delete(BucketSourceOption.metagenerationMatch());
if (deleted) {
  // the bucket was deleted
} else {
  // the bucket was not found
}

Node.js

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

Ver no GitHub Feedback

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

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

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

// Deletes the bucket
await storage.bucket(bucketName).delete();

console.log(`Bucket ${bucketName} deleted.`);

PHP

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

Ver no GitHub Feedback

use Google\Cloud\Storage\StorageClient;

/**
 * Delete a Cloud Storage Bucket.
 *
 * @param string $bucketName the name of the bucket to delete.
 *
 * @return void
 */
function delete_bucket($bucketName)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $bucket->delete();
    printf('Bucket deleted: %s' . PHP_EOL, $bucket->name());
}

Python

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

Ver no GitHub Feedback

def delete_bucket(bucket_name):
    """Deletes a bucket. The bucket must be empty."""
    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    bucket.delete()
    print('Bucket {} deleted'.format(bucket.name))

Ruby

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

Ver no GitHub Feedback

# project_id  = "Your Google Cloud project ID"
# bucket_name = "Name of your Google Cloud Storage bucket to delete"

require "google/cloud/storage"

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

bucket.delete

puts "Deleted bucket: #{bucket.name}"

APIs REST

API JSON

Observe que é necessário esvaziar o intervalo para poder excluí-lo.

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
2. Use cURL (em inglês) para chamar a API JSON, substituindo [VALUES_IN_BRACKETS] pelos valores apropriados:

   curl -X DELETE -H "Authorization: Bearer [OAUTH2_TOKEN]" \
       "https://www.googleapis.com/storage/v1/b/www.example.com"

Se bem-sucedido, a resposta conterá o código de status 204.

Para mais informações, consulte a página de referência de JSON Excluir intervalos.

API XML

Observe que é necessário esvaziar o intervalo para poder excluí-lo.

1. Consiga um token de acesso de autorização do OAuth 2.0 Playground. Configure o Playground para usar suas credenciais do OAuth.
2. Use cURL (em inglês) para chamar a API XML, substituindo [VALUES_IN_BRACKETS] pelos valores apropriados:

   curl -X DELETE -H "Authorization: Bearer [OAUTH2_TOKEN]" \
       "https://storage.googleapis.com/www.example.com"

Para mais informações, consulte a página de referência de XML Excluir intervalos.

A seguir

• Veja exemplos e dicas para usar intervalos para hospedar um site estático.
• Visite 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.
• Saiba mais sobre o horário comercial do Cloud Storage para hospedar um site estático.
• Saiba mais sobre todas as opções de disponibilização na Web.
• Conheça outros tutoriais do Google Cloud Platform que usam o Cloud Storage.