View a markdown version of this page

Fazer solicitações usando credenciais de usuário do IAM ou da Conta da AWS - Amazon Simple Storage Service
Para criar um arquivo de credenciais da AWS localEnviar solicitações autenticadas usando os AWS SDKsRecursos relacionados

Fazer solicitações usando credenciais de usuário do IAM ou da Conta da AWS

É possível usar suas credenciais de segurança de usuário do IAM ou da Conta da AWS para enviar solicitações autenticadas ao Amazon S3. Esta seção fornece exemplos de como você pode enviar solicitações autenticadas usando o AWS SDK para Java, o AWS SDK para .NET e o AWS SDK para PHP. Para obter uma lista de AWS SDKs disponíveis, acesse Código de exemplo e bibliotecas.

Cada um desses AWS SDKs usa uma cadeia de provedor de credenciais específicas do SDK para encontrar e usar credenciais, além de realizar ações em nome do proprietário das credenciais. O que todas essas cadeias de provedor de credenciais têm em comum é que elas procuram por seu arquivo local de credenciais da AWS.

Para obter mais informações, consulte os tópicos abaixo.

Para criar um arquivo de credenciais da AWS local

A forma mais fácil de configurar credenciais para os AWS SDKs é usar um arquivo de credenciais da AWS. Se você utiliza a AWS Command Line Interface (AWS CLI), já deve ter um arquivo de credenciais da AWS local configurado. Caso contrário, use o procedimento a seguir para configurar um arquivo de credenciais:

  1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em https://console.aws.amazon.com/iam/.

  2. Crie um novo usuário com permissões limitadas aos serviços e ações aos quais você deseja que seu código tenha acesso. Para obter mais informações sobre como criar um usuário, consulte Criar usuários do IAM (console) e siga as instruções até a etapa 8.

  3. Escolha Download .csv (Fazer download do arquivo .csv) para salvar uma cópia de suas credenciais da AWS.

  4. Em seu computador, navegue para seu diretório inicial e crie um diretório .aws. Nos sistemas baseados em Unix, como Linux ou OS X, isso fica no seguinte local:

    ~/.aws

    No Windows, isso está no seguinte local:

    %HOMEPATH%\.aws

  5. No diretório .aws, crie um novo arquivo chamado credentials.

  6. Abra o arquivo de credenciais .csv que você baixou do console do IAM e copie o conteúdo dele para o arquivo credentials usando o seguinte formato:

    [default]
aws_access_key_id = your_access_key_id
aws_secret_access_key = your_secret_access_key

  7. Salve o arquivo credentials e exclua o arquivo .csv que você baixou na etapa 3.

Seu arquivo de credenciais compartilhado agora está configurado em seu computador local, e ele está pronto para ser usado com os AWS SDKs.

Enviar solicitações autenticadas usando os AWS SDKs

Use os AWS SDKs para enviar solicitações autenticadas. Para obter mais informações sobre o envio de solicitações autenticadas, consulte Credenciais de segurança da AWS ou Autenticação do IAM Identity Center.

Java

Para obter informações sobre como autenticar solicitações usando o SDK da AWS para Java, consulte Uso de arquivos compartilhados de configuração e credenciais para configurar globalmente ferramentas e SDKs da AWS e Autenticação e acesso usando ferramentas e SDKs da AWS no Guia de referência de ferramentas e SDKs da AWS.

.NET

Para enviar solicitações autenticadas usando as credenciais de Conta da AWS ou de usuário do IAM:

  • Crie uma instância da classe AmazonS3Client.

  • Execute um dos métodos do AmazonS3Client para enviar solicitações ao Amazon S3. O cliente gera a assinatura necessária das credenciais que você fornece e a inclui na solicitação enviada ao Amazon S3.

Para obter mais informações, consulte Como fazer solicitações usando credenciais de usuário do IAM ou da conta da AWS.

nota

  • Você pode criar o cliente AmazonS3Client sem fornecer suas credenciais de segurança. As solicitações enviadas usando esse cliente são solicitações anônimas, sem uma assinatura. O Amazon S3 retorna um erro se você enviar solicitações anônimas para um recurso que não esteja disponível publicamente.

  • Você pode criar uma Conta da AWS e criar os usuários necessários. Você também pode gerenciar credenciais para esses usuários. Você precisa dessas credenciais para executar a tarefa no exemplo a seguir. Para obter mais informações, consulte Configurar credenciais da AWS no Guia do desenvolvedor do SDK para .NET.

    Em seguida, você também pode configurar seu aplicativo para recuperar ativamente perfis e credenciais e, em seguida, usar explicitamente essas credenciais ao criar um cliente de serviço da AWS. Para obter mais informações, consulte Acessando credenciais e perfis em uma aplicação no Guia do desenvolvedor do SDK para .NET.

O exemplo de C# a seguir mostra como realizar as tarefas anteriores. Para obter informações sobre como configurar e executar exemplos de código, consulte Conceitos básicos do AWS SDK for .NET no Guia do desenvolvedor do AWS SDK for .NET.

exemplo
using Amazon;
using Amazon.S3;
using Amazon.S3.Model;
using System;
using System.Threading.Tasks;

namespace Amazon.DocSamples.S3
{
    class MakeS3RequestTest
    {
        private const string bucketName = "*** bucket name ***"; 
        // Specify your bucket region (an example region is shown).
        private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2;
        private static IAmazonS3 client;

        public static void Main()
        {
            using (client = new AmazonS3Client(bucketRegion))
            {
                Console.WriteLine("Listing objects stored in a bucket");
                ListingObjectsAsync().Wait();
            }
        }

        static async Task ListingObjectsAsync()
        {
            try
            {
                ListObjectsRequest request = new ListObjectsRequest
                {
                    BucketName = bucketName,
                    MaxKeys = 2
                };
                do
                {
                    ListObjectsResponse response = await client.ListObjectsAsync(request);
                    // Process the response.
                    foreach (S3Object entry in response.S3Objects)
                    {
                        Console.WriteLine("key = {0} size = {1}",
                            entry.Key, entry.Size);
                    }

                    // If the response is truncated, set the marker to get the next 
                    // set of keys.
                    if (response.IsTruncated)
                    {
                        request.Marker = response.NextMarker;
                    }
                    else
                    {
                        request = null;
                    }
                } while (request != null);
            }
            catch (AmazonS3Exception e)
            {
                Console.WriteLine("Error encountered on server. Message:'{0}' when writing an object", e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message);
            }
        }
    }
}
PHP

Esta seção explica como usar uma classe da versão 3 do AWS SDK para PHP para enviar solicitações autenticadas usando suas credenciais da Conta da AWS ou de usuário do IAM. Para obter mais informações sobre a API do AWS SDK for Ruby, acesse AWS SDK for Ruby Version 2.

O exemplo de PHP a seguir mostra como o cliente faz uma solicitação usando suas credenciais de segurança para listar todos os buckets para a sua conta.

exemplo
 
require 'vendor/autoload.php';

use Aws\S3\Exception\S3Exception;
use Aws\S3\S3Client;

$bucket = '*** Your Bucket Name ***';

$s3 = new S3Client([
    'region' => 'us-east-1',
    'version' => 'latest',
]);

// Retrieve the list of buckets.
$result = $s3->listBuckets();

try {
    // Retrieve a paginator for listing objects.
    $objects = $s3->getPaginator('ListObjects', [
        'Bucket' => $bucket
    ]);

    echo "Keys retrieved!" . PHP_EOL;

    // Print the list of objects to the page.
    foreach ($objects as $object) {
        echo $object['Key'] . PHP_EOL;
    }
} catch (S3Exception $e) {
    echo $e->getMessage() . PHP_EOL;
}
nota

Você pode criar o cliente S3Client sem fornecer suas credenciais de segurança. As solicitações enviadas usando esse cliente são solicitações anônimas, sem uma assinatura. O Amazon S3 retorna um erro se você enviar solicitações anônimas para um recurso que não esteja disponível publicamente. Para obter mais informações, consulte Criar clientes anônimos na Documentação do AWS SDK para PHP.

Ruby

Para poder usar a versão 3 do AWS SDK para Ruby para fazer chamadas para o Amazon S3, defina as credenciais de acesso da AWS que o SDK usa para verificar acesso aos seus buckets e objetos. Se você compartilhou credenciais configuradas no perfil de credenciais da AWS no sistema local, a versão 3 do SDK for Ruby poderá usar essas credenciais sem que você precise declará-las no código. Para obter mais informações sobre como configurar credenciais compartilhadas, consulte Como fazer solicitações usando credenciais de usuário do IAM ou da conta da AWS.

O trecho de código seguinte do Ruby usa as credenciais de um arquivo de credenciais da AWS compartilhado em um computador local para autenticar uma solicitação a fim de obter todos os nomes de chaves de objeto em um bucket específico. Ela faz o seguinte:

  1. Cria uma instância da classe Aws::S3::Client.

  2. Faz uma solicitação para o Amazon S3, enumerando objetos em um bucket com o método list_objects_v2 do Aws::S3::Client. O cliente gera o valor de assinatura necessário com base nas credenciais do arquivo de credenciais da AWS em seu computador e o inclui na solicitação que envia ao Amazon S3.

  3. Imprime o array de nomes de chaves de objeto no terminal.

exemplo

# Prerequisites:
#  - An existing Amazon S3 bucket.

require 'aws-sdk-s3'

# @param s3_client [Aws::S3::Client] An initialized Amazon S3 client.
# @param bucket_name [String] The bucket's name.
# @return [Boolean] true if all operations succeed; otherwise, false.
# @example
#   s3_client = Aws::S3::Client.new(region: 'us-west-2')
#   exit 1 unless list_bucket_objects?(s3_client, 'amzn-s3-demo-bucket')
def list_bucket_objects?(s3_client, bucket_name)
  puts "Accessing the bucket named '#{bucket_name}'..."
  objects = s3_client.list_objects_v2(
    bucket: bucket_name,
    max_keys: 50
  )

  if objects.count.positive?
    puts 'The object keys in this bucket are (first 50 objects):'
    objects.contents.each do |object|
      puts object.key
    end
  else
    puts 'No objects found in this bucket.'
  end

  true
rescue StandardError => e
  puts "Error while accessing the bucket named '#{bucket_name}': #{e.message}"
  false
end

# Example usage:
def run_me
  region = 'us-west-2'
  bucket_name = 'BUCKET_NAME'
  s3_client = Aws::S3::Client.new(region: region)

  exit 1 unless list_bucket_objects?(s3_client, bucket_name)
end

run_me if $PROGRAM_NAME == __FILE__

Se você não tiver um arquivo de credenciais da AWS local, ainda poderá criar o recurso Aws::S3::Client e executar o código nos buckets e objetos do Amazon S3. As solicitações enviadas usando a versão 3 do SDK para Ruby são anônimas, sem assinatura por padrão. O Amazon S3 retornará um erro se você enviar solicitações anônimas para um recurso que não esteja disponível publicamente.

É possível usar e expandir o trecho de código anterior para aplicações do SDK para Ruby, como no seguinte exemplo mais robusto. 


# Prerequisites:
#  - An existing Amazon S3 bucket.

require 'aws-sdk-s3'

# @param s3_client [Aws::S3::Client] An initialized Amazon S3 client.
# @param bucket_name [String] The bucket's name.
# @return [Boolean] true if all operations succeed; otherwise, false.
# @example
#   s3_client = Aws::S3::Client.new(region: 'us-west-2')
#   exit 1 unless list_bucket_objects?(s3_client, 'amzn-s3-demo-bucket')
def list_bucket_objects?(s3_client, bucket_name)
  puts "Accessing the bucket named '#{bucket_name}'..."
  objects = s3_client.list_objects_v2(
    bucket: bucket_name,
    max_keys: 50
  )

  if objects.count.positive?
    puts 'The object keys in this bucket are (first 50 objects):'
    objects.contents.each do |object|
      puts object.key
    end
  else
    puts 'No objects found in this bucket.'
  end

  true
rescue StandardError => e
  puts "Error while accessing the bucket named '#{bucket_name}': #{e.message}"
  false
end

# Example usage:
def run_me
  region = 'us-west-2'
  bucket_name = 'BUCKET_NAME'
  s3_client = Aws::S3::Client.new(region: region)

  exit 1 unless list_bucket_objects?(s3_client, bucket_name)
end

run_me if $PROGRAM_NAME == __FILE__
Go
exemplo

O exemplo a seguir usa credenciais da AWS carregadas automaticamente pelo SDK para Go pelo arquivo de credenciais compartilhado.


package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/aws/aws-sdk-go-v2/config"
	"github.com/aws/aws-sdk-go-v2/service/s3"
	"github.com/aws/smithy-go"
)

// main uses the AWS SDK for Go V2 to create an Amazon Simple Storage Service
// (Amazon S3) client and list up to 10 buckets in your account.
// This example uses the default settings specified in your shared credentials
// and config files.
func main() {
	ctx := context.Background()
	sdkConfig, err := config.LoadDefaultConfig(ctx)
	if err != nil {
		fmt.Println("Couldn't load default configuration. Have you set up your AWS account?")
		fmt.Println(err)
		return
	}
	s3Client := s3.NewFromConfig(sdkConfig)
	count := 10
	fmt.Printf("Let's list up to %v buckets for your account.\n", count)
	result, err := s3Client.ListBuckets(ctx, &s3.ListBucketsInput{})
	if err != nil {
		var ae smithy.APIError
		if errors.As(err, &ae) && ae.ErrorCode() == "AccessDenied" {
			fmt.Println("You don't have permission to list buckets for this account.")
		} else {
			fmt.Printf("Couldn't list buckets for your account. Here's why: %v\n", err)
		}
		return
	}
	if len(result.Buckets) == 0 {
		fmt.Println("You don't have any buckets!")
	} else {
		if count > len(result.Buckets) {
			count = len(result.Buckets)
		}
		for _, bucket := range result.Buckets[:count] {
			fmt.Printf("\t%v\n", *bucket.Name)
		}
	}
}

Recursos relacionados