Primeiros passos na autenticação

Neste artigo, você aprende a maneira recomendada para autenticar uma API do Cloud.

A autenticação é o processo de determinação da identidade de um cliente A autorização é o processo que determina quais permissões um cliente autenticado tem para um conjunto de recursos. Ou seja, a autenticação identifica quem você é e a autorização determina o que é possível fazer.

Para autenticação, em vez de um usuário específico, recomendamos usar uma conta de serviço, uma Conta do Google associada ao seu projeto do GCP. As contas de serviço são usadas para autenticação, independentemente do local em que seu código é executado. Por exemplo, localmente, no Compute Engine, no App Engine etc. Para mais informações sobre outros tipos de autenticação, consulte a visão geral sobre autenticação.

Como criar uma conta de serviço

all

Como configurar a variável de ambiente

Se você planeja usar uma conta de serviço, será necessário definir uma variável de ambiente.

display_as_tabs

Com a configuração da variável de ambiente, você fornece credenciais separadamente do seu aplicativo, sem alterar o código do aplicativo na implantação. Como alternativa, especifique explicitamente o caminho para o arquivo de chave da conta de serviço no seu código. Para mais informações, consulte o guia de produção.

Como verificar a autenticação

Após configurar a variável de ambiente, não é necessário especificar de modo explícito as credenciais no código ao utilizar uma biblioteca de cliente do Google Cloud. A biblioteca de cliente determina suas credenciais de modo implícito. Por esse motivo, para verificar o funcionamento da autenticação, configure a variável de ambiente e execute o código da biblioteca de cliente, conforme demonstrado no exemplo a seguir. Se a solicitação for bem-sucedida, a autenticação funcionará.

É necessário instalar a biblioteca de cliente do Cloud Storage para executar o exemplo a seguir.

C#

public object AuthImplicit(string projectId)
    {
        // If you don't specify credentials when constructing the client, the
        // client library will look for credentials in the environment.
        var credential = GoogleCredential.GetApplicationDefault();
        var storage = StorageClient.Create(credential);
        // Make an authenticated API request.
        var buckets = storage.ListBuckets(projectId);
        foreach (var bucket in buckets)
        {
            Console.WriteLine(bucket.Name);
        }
        return null;
    }

Go


    // implicit uses Application Default Credentials to authenticate.
    func implicit() {
    	ctx := context.Background()

    	// For API packages whose import path is starting with "cloud.google.com/go",
    	// such as cloud.google.com/go/storage in this case, if there are no credentials
    	// provided, the client library will look for credentials in the environment.
    	storageClient, err := storage.NewClient(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}

    	it := storageClient.Buckets(ctx, "project-id")
    	for {
    		bucketAttrs, err := it.Next()
    		if err == iterator.Done {
    			break
    		}
    		if err != nil {
    			log.Fatal(err)
    		}
    		fmt.Println(bucketAttrs.Name)
    	}

    	// For packages whose import path is starting with "google.golang.org/api",
    	// such as google.golang.org/api/cloudkms/v1, use NewService to create the client.
    	kmsService, err := cloudkms.NewService(ctx)
    	if err != nil {
    		log.Fatal(err)
    	}

    	_ = kmsService
    }

Java

static void authImplicit() {
      // If you don't specify credentials when constructing the client, the client library will
      // look for credentials via the environment variable GOOGLE_APPLICATION_CREDENTIALS.
      Storage storage = StorageOptions.getDefaultInstance().getService();

      System.out.println("Buckets:");
      Page<Bucket> buckets = storage.list();
      for (Bucket bucket : buckets.iterateAll()) {
        System.out.println(bucket.toString());
      }
    }

Node.js

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

    // Instantiates a client. If you don't specify credentials when constructing
    // the client, the client library will look for credentials in the
    // environment.
    const storage = new Storage();

    try {
      // Makes an authenticated API request.
      const results = await storage.getBuckets();

      const [buckets] = results;

      console.log('Buckets:');
      buckets.forEach(bucket => {
        console.log(bucket.name);
      });
    } catch (err) {
      console.error('ERROR:', err);
    }

PHP

// Imports the Cloud Storage client library.
    use Google\Cloud\Storage\StorageClient;

    function auth_cloud_implicit($projectId)
    {
        $config = [
            'projectId' => $projectId,
        ];

        # If you don't specify credentials when constructing the client, the
        # client library will look for credentials in the environment.
        $storage = new StorageClient($config);

        # Make an authenticated API request (listing storage buckets)
        foreach ($storage->buckets() as $bucket) {
            printf('Bucket: %s' . PHP_EOL, $bucket->name());
        }
    }

Python

def implicit():
        from google.cloud import storage

        # If you don't specify credentials when constructing the client, the
        # client library will look for credentials in the environment.
        storage_client = storage.Client()

        # Make an authenticated API request
        buckets = list(storage_client.list_buckets())
        print(buckets)

Ruby

# project_id = "Your Google Cloud project ID"

    require "google/cloud/storage"

    # If you don't specify credentials when constructing the client, the client
    # library will look for credentials in the environment.
    storage = Google::Cloud::Storage.new project: project_id

    # Make an authenticated API request
    storage.buckets.each do |bucket|
      puts bucket.name
    end

A seguir