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. Eles não podem conter conteúdo dinâmico, como scripts do servidor, como PHP. Para obter mais informações sobre páginas da Web estáticas, como exemplos e dicas, consulte a página do site estático.

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

Atenção: Este tutorial se aplica ao uso de HTTP. Recomendamos que você não veicule um conteúdo que contenha dados confidenciais ou particulares via HTTP 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, usamos o seguinte componente faturável do Google Cloud:

• Cloud Storage

Consulte as dicas na seção Monitorar suas cobranças de armazenamento 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 GCP, na página do seletor de projetos, selecione ou crie um projeto do GCP.

   Observação: caso não queira manter os recursos criados usando este procedimento, crie um projeto em vez de selecionar um já existente. Depois de concluir essas etapas, é possível excluir o projeto, basta remover todos os recursos associados a ele.

   Acesse a página do seletor de projetos

3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform. Saiba como confirmar que o faturamento está ativado para 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á 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. Para www.example.com, o registro CNAME pode conter as seguintes informações:

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

Para obter mais informações sobre redirecionamentos de CNAME, consulte a URI para Alias de .

Para conectar seu domínio ao Cloud Storage:

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

   Seu serviço de registro 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: O DNS não é compatível com a criação de um registro CNAME em um domínio raiz, como example.com , então, na maioria dos casos, é preciso criar seu registro de CNAME em um subdomínio, como www.example.com ou myblog.example.com. Alguns provedores DNS oferecem um recurso não padrão que permite que um domínio raiz tenha um alias para outro nome sem o uso de CNAME. Consulte a documentação do provedor de DNS para determinar se esse recurso está disponível.

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 www.example.com para 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.
   Abrir o navegador do Cloud Storage

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

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

   • O Nome do intervalo.

   • A Classe de armazenamento e o Local do intervalo.

   • O Modelo de controle de acesso do intervalo.

4. Clique em Criar

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

gsutil

Use o comando gsutil mb:

gsutil mb 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++ (em inglês).

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# (em inglês).

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

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

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

Ver no GitHub 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();

PHP

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

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.
 *
 */
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 (em inglês).

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

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

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

gsutil

Use o comando gsutil cp para copiar arquivos para o intervalo. 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++ (em inglês).

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# (em inglês).

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

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

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

Ver no GitHub 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();

PHP

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

É possível usar o método File.createWriteStream() para fazer upload de um objeto escrevendo em um fluxo.

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

Use o método Blob.upload_from_file(), Blob.upload_from_filename() ou Blob.upload_from_string() (links em inglês) para fazer o 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."""
    # 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 (em inglês).

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

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

• 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 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

Você pode atribuir um sufixo de página de índice, que é controlado pela propriedade MainPageSuffix e por uma página de erro personalizada, que é 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, 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ê defina MainPageSuffix do seu site estático como index.html. Além disso, digamos que você não tenha um arquivo chamado directory no seu intervalo www.example.com. Nessa situação, se um usuário solicitar o URL http://www.example.com/directory, o Cloud Storage tenta veicular 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 exibido 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 tenta veicular o arquivo www.example.com/index.html.

Para obter mais informações sobre os casos em que a página de índice é veiculada, consulte Exemplos de configuração do site.

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. Se você tiver atribuído um MainPageSuffix, o Cloud Storage só retornará a página de erro 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 que controla qual arquivo atua como a página de erro é NotFoundPage. Se você não definir NotFoundPage, os usuários recebem uma página de erro genérica.

Definindo MainPageSuffix e NotFoundPage

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 intervalos, encontre o intervalo que você criou.

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

   Observação: esta opção só está disponível para intervalos com nome correspondente a um padrão válido 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 .

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.

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 Intervalo. 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 Intervalo 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 testar o site

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

Por exemplo, se você tiver um objeto denominado test.html armazenado em um intervalo denominado www.example.com, verifique se ele está acessível indo para www.example.com/test.html no seu navegador.

Como fazer a limpeza

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 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 GCP, 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 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.
   Abrir o navegador do Cloud Storage

2. Marque a caixa de seleção associada ao intervalo que você quer 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 de -r para excluir o intervalo e o conteúdo de 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 Cloud Storage para C++ (em inglês).

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# (em inglês).

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

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

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

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

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

Ver no GitHub Feedback

from google.cloud import storage

def delete_bucket(bucket_name):
    """Deletes a bucket. The bucket must be empty."""
    # bucket_name = "your-bucket-name"

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

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

Observação: o intervalo precisa estar vazio antes de ser excluído.

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 DELETE intervalo:

   curl -X DELETE \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     "https://storage.googleapis.com/storage/v1/b/www.example.com"

Se funcionar, a resposta conterá o código de status 204.

API XML

Observação: o intervalo precisa estar vazio antes de ser excluído.

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 DELETE intervalo:

   curl -X DELETE \
     -H "Authorization: Bearer ya29.AHES6ZRVmB7fkLtd1XTmq6mo0S1wqZZi3-Lh_s-6Uw7p8vtgSwg" \
     "https://storage.googleapis.com/www.example.com"

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 exibição na Web.
• Teste outros tutoriais do Google Cloud que usam o Cloud Storage.