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.

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 a seção Como monitorar cobranças de armazenamento para saber mais sobre as cobranças ligadas à hospedagem de um site estático e consulte a página Preços para ver os detalhes dos 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 GCP.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado para o projeto.

    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. 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 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 precisa permitir que você administre seu domínio, inclusive para adicionar um registro CNAME. Por exemplo, se você usa o Google Domains, as instruções para adicionar registros de recursos como CNAME podem ser encontradas na página de Ajuda do Google Domains, na seção Registros de recursos.

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 Cloud Storage de C++.

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

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.

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.

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.

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

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.

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.

# 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:
  3. {
    "name": "www.example.com"
    }
  4. Use o cURL para chamar a API JSON. Para 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 o cURL para chamar a API XML para criar um intervalo com o nome do seu site. Para 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 site em um intervalo.
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 saber mais, consulte a documentação de referência da API Cloud Storage C++.

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

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.

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.

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.

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

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(), Blob.upload_from_filename() ou Blob.upload_from_string() para fazer o upload de um objeto.
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.

# 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 o cURL para chamar a API JSON com uma solicitação POST Object. 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://www.googleapis.com/upload/storage/v1/b/www.example.com/o?uploadType=media&name=index.html"

Consulte Como fazer um upload simples para mais informações sobre como fazer o 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 o cURL para chamar a API JSON com uma solicitação PUT Object. 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"

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.

Se optar por controlar a acessibilidade de arquivos individuais, será possível definir a ACL padrão de objetos para o intervalo de modo que os próximos arquivos carregados no intervalo sejam compartilhados por padrão.

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 mais ações More actions icon. ao lado do intervalo e selecione Editar configuração de website.

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

  5. Clique em Save.

gsutil

Use o comando gsutil web set para definir a propriedade MainPageSuffix com a sinalização -m e o NotFoundPage com a sinalização -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/...

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 o cURL para chamar a API JSON com uma solicitação PATCH Bucket. Para 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 para chamar a API XML com uma solicitação PUT Bucket e parâmetro de string de consulta 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

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.

Limpar

Depois de concluir o tutorial de como hospedar um site estático, limpe os recursos criados no Google Cloud Platform para que eles não ocupem cotas e sejam cobrados no futuro. Nas seções a seguir, veja como excluir e desativar esses recursos.

Como excluir o projeto

A maneira mais fácil de evitar o faturamento é excluir o projeto criado para o tutorial.

Para excluir o projeto:

  1. No console do GCP, acesse a página "Projetos".

    Acessar a página Projetos

  2. Na lista de projetos, selecione o que você quer excluir e clique em Excluir projeto. Após marcar a caixa de seleção ao lado do nome do projeto, 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 Cloud Storage C++.

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

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.

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.

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.

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

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.

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.

# 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 o cURL 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-sucedida, 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 o cURL 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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.