As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Carregue credenciais de um processo externo usando o AWS SDK for Java 2.x **Atenção** A seguir, descrevemos um método de obtenção de credenciais temporárias de um processo externo. Isto pode ser potencialmente perigoso, portanto, prossiga com cuidado. É recomendável utilizar outros provedores de credenciais, se possível. Ao usar esta opção, recomendamos que você se certifique de que o arquivo `config` esteja o mais bloqueado possível usando as práticas recomendadas de segurança para seu sistema operacional. Certifique-se de que sua ferramenta de credenciais personalizadas não grave nenhuma informação secreta em. `StdErr` SDKs e AWS CLI pode capturar e registrar essas informações, potencialmente expondo-as a usuários não autorizados. Com o SDK para Java 2.x, você pode adquirir credenciais temporárias de um processo externo para casos de uso personalizados. Há duas maneiras de configurar essa funcionalidade. ## Usar a configuração `credential_process` Se você tiver um método que forneça credenciais temporárias, poderá integrá-lo adicionando a configuração `credential_process` como parte de uma definição de perfil no arquivo `config`. O valor especificado deve usar o caminho completo para o arquivo de comando. Se o caminho do arquivo contiver espaços, você deverá colocá-lo entre aspas. O SDK chama o comando exatamente como determinado e, em seguida, lê dados JSON de `stdout`. Os exemplos a seguir mostram o uso dessa configuração para caminhos de arquivo sem espaços e caminhos de arquivo com espaços. ------ #### [ Linux/macOS ] **Sem espaços no caminho do arquivo** ``` [profile process-credential-profile] credential_process = /path/to/credential/file/credential_file.sh --custom-command custom_parameter ``` **Espaços no caminho do arquivo** ``` [profile process-credential-profile] credential_process = "/path/with/space to/credential/file/credential_file.sh" --custom-command custom_parameter ``` ------ #### [ Windows ] **Sem espaços no caminho do arquivo** ``` [profile process-credential-profile] credential_process = C:\Path\To\credentials.cmd --custom_command custom_parameter ``` **Espaços no caminho do arquivo** ``` [profile process-credential-profile] credential_process = "C:\Path\With Space To\credentials.cmd" --custom_command custom_parameter ``` ------ O trecho de código a seguir demonstra como criar um cliente de serviço que usa as credenciais temporárias definidas como parte do perfil nomeado `process-credential-profile`. ``` Region region = Region.US_WEST_2; S3Client s3Client = S3Client.builder() .region(region) .credentialsProvider(ProfileCredentialsProvider.create("process-credential-profile")) .build(); ``` Para obter informações detalhadas sobre o uso de um processo externo como fonte de credenciais temporárias, consulte a [seção de credenciais do processo no Guia](https://docs.aws.amazon.com/sdkref/latest/guide/feature-process-credentials.html) de referência de ferramentas AWS SDKs e ferramentas. ## Usar um `ProcessCredentialsProvider` Como alternativa ao uso das configurações no arquivo `config`, você pode usar o `[ProcessCredentialsProvider](https://sdk.amazonaws.com/java/api/latest/software/amazon/awssdk/auth/credentials/ProcessCredentialsProvider.html)` de SDKs para carregar credenciais temporárias usando Java. Os exemplos a seguir mostram várias versões de como especificar um processo externo usando o `ProcessCredentialsProvider` e configurando um cliente de serviço que usa as credenciais temporárias. ------ #### [ Linux/macOS ] **Sem espaços no caminho do arquivo** ``` ProcessCredentialsProvider credentials = ProcessCredentialsProvider .builder() .command("/path/to/credentials.sh optional_param1 optional_param2") .build(); S3Client s3 = S3Client.builder() .region(Region.US_WEST_2) .credentialsProvider(credentials) .build(); ``` **Espaços no caminho do arquivo** ``` ProcessCredentialsProvider credentials = ProcessCredentialsProvider .builder() .command("/path\\ with\\ spaces\\ to/credentials.sh optional_param1 optional_param2") .build(); S3Client s3 = S3Client.builder() .region(Region.US_WEST_2) .credentialsProvider(credentials) .build(); ``` ------ #### [ Windows ] **Sem espaços no caminho do arquivo** ``` ProcessCredentialsProvider credentials = ProcessCredentialsProvider .builder() .command("C:\\Path\\To\\credentials.exe optional_param1 optional_param2") .build(); S3Client s3 = S3Client.builder() .region(Region.US_WEST_2) .credentialsProvider(credentials) .build(); ``` **Espaços no caminho do arquivo** ``` ProcessCredentialsProvider credentials = ProcessCredentialsProvider .builder() .command("\"C:\\Path\\With Spaces To\\credentials.exe\" optional_param1 optional_param2") .build(); S3Client s3 = S3Client.builder() .region(Region.US_WEST_2) .credentialsProvider(credentials) .build(); ``` ------ ## Usar o IAM Roles Anywhere para autenticação O [IAM Roles Anywhere](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html) permite AWS service (Serviço da AWS) que você obtenha AWS credenciais temporárias para cargas de trabalho executadas fora do. AWS Ele permite acesso seguro a recursos da AWS de ambientes on-premises ou de outros ambientes de nuvem. Antes de autenticar solicitações com o IAM Roles Anywhere, primeiro você precisa reunir as informações necessárias e baixar a [ferramenta de assistente de credenciais](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html). Seguindo as instruções em [Conceitos básicos](https://docs.aws.amazon.com/rolesanywhere/latest/userguide/getting-started.html) no Guia do usuário do IAM Roles Anywhere, você pode criar os artefatos necessários. O SDK para Java não tem um provedor de credenciais dedicado para recuperar credenciais temporárias do IAM Roles Anywhere, mas você pode usar a ferramenta de assistente de credenciais junto com uma das opções para [recuperar credenciais de um processo externo](#credentials-process). ### Usar a configuração `credential_process` em um perfil O trecho a seguir no arquivo de AWS configuração compartilhado mostra um perfil chamado `roles_anywhere` que usa a configuração: `credential_process` ``` [profile roles_anywhere] credential_process = ./aws_signing_helper credential-process \ --certificate /path/to/certificate \ --private-key /path/to/private-key \ --trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \ --profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \ --role-arn arn:aws:iam::account:role/role-name-with-path ``` Você precisa substituir o texto mostrado em vermelho por seus valores depois de reunir todos os artefatos. O primeiro elemento na configuração, `aws_signing_helper`, é o executável da ferramenta de assistente de credenciais e `credential-process` é o comando. Quando você configura um cliente de serviço para usar o perfil `roles_anywhere`, conforme mostrado no código a seguir, o SDK armazena em cache as credenciais temporárias e as atualiza antes que elas expirem: ``` S3Client s3Client = S3Client.builder() .credentialsProvider(ProfileCredentialsProvider.builder() .profileName("roles_anywhere").build()) .build(); ``` ### Configurar um `ProcessCredentialsProvider` Conforme mostrado a seguir, é possível usar uma abordagem somente de código com o `ProcessCredentialsProvider` em vez de usar as configurações de perfil: ``` ProcessCredentialsProvider processCredentialsProvider = ProcessCredentialsProvider.builder() .command(""" ./aws_signing_helper credential-process \ --certificate /path/to/certificate \ --private-key /path/to/private-key \ --trust-anchor-arn arn:aws:rolesanywhere:region:account:trust-anchor/TA_ID \ --profile-arn arn:aws:rolesanywhere:region:account:profile/PROFILE_ID \ --role-arn arn:aws:iam::account:role/role-name-with-path """).build(); S3Client s3Client = S3Client.builder() .credentialsProvider(processCredentialsProvider) .build(); ``` Substitua o texto mostrado em vermelho por seus valores depois de reunir todos os artefatos.