Gere uma chave de API Amazon Bedrock - Amazon Bedrock
Gere uma chave de API usando o consoleGere uma chave de APIGere uma chave de API de curto prazo usando uma bibliotecaConfigure a atualização automática de chaves de API Amazon Bedrock de curto prazo

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

Gere uma chave de API Amazon Bedrock

Você pode gerar uma chave de API do Amazon Bedrock usando a API AWS Management Console ou a AWS API. Recomendamos que você use o AWS Management Console para gerar facilmente uma chave de API do Amazon Bedrock com algumas etapas.

Atenção

É altamente recomendável restringir o uso das chaves de API do Amazon Bedrock para a exploração do Amazon Bedrock. Quando estiver pronto para incorporar o Amazon Bedrock em aplicativos com maiores requisitos de segurança, você deve mudar para credenciais de curto prazo. Para obter mais informações, consulte Alternativas às chaves de acesso de longo prazo no Guia do usuário do IAM.

Gere uma chave de API do Amazon Bedrock usando o console

Para gerar uma chave de API do Amazon Bedrock usando o console, faça o seguinte:

  1. Faça login no AWS Management Console com uma identidade do IAM que tenha permissões para usar o console Amazon Bedrock. Em seguida, abra o console Amazon Bedrock em https://console.aws.amazon.com/bedrock.

  2. No painel de navegação esquerdo, selecione Chaves de API.

  3. Gere um dos seguintes tipos de chaves:

    • Chave de API de curto prazo — Na guia Chaves de API de curto prazo, escolha Gerar chaves de API de curto prazo. A chave expira quando a sessão do console expira (e não mais do que 12 horas) e permite que você faça chamadas para Região da AWS aquela de onde você a gerou. Você pode modificar a região diretamente na chave gerada.

    • Chave de API de longo prazo — Na guia Chaves de API de longo prazo, escolha Gerar chaves de API de longo prazo.

      1. Na seção Expiração da chave de API, escolha um horário após o qual a chave expirará.

      2. (Opcional) Por padrão, a política AmazonBedrockLimitedAccess AWS gerenciada, que concede acesso às principais operações da API Amazon Bedrock, é anexada ao usuário do IAM associado à chave. Para selecionar mais políticas para anexar ao usuário, expanda a seção Permissões avançadas e selecione as políticas que você deseja adicionar.

      3. Escolha Gerar.

      Atenção

      É altamente recomendável restringir o uso das chaves de API do Amazon Bedrock para a exploração do Amazon Bedrock. Quando estiver pronto para incorporar o Amazon Bedrock em aplicativos com maiores requisitos de segurança, você deve mudar para credenciais de curto prazo. Para obter mais informações, consulte Alternativas às chaves de acesso de longo prazo no Guia do usuário do IAM.

Gere uma chave de API Amazon Bedrock de longo prazo usando a API

As etapas gerais para criar uma chave de API Amazon Bedrock de longo prazo na API são as seguintes:

  1. Crie um usuário do IAM enviando uma CreateUsersolicitação com um endpoint do IAM.

  2. Anexe o AmazonBedrockLimitedAccessao usuário do IAM enviando uma AttachUserPolicysolicitação com um endpoint do IAM. Você pode repetir essa etapa para anexar outras políticas gerenciadas ou personalizadas, conforme necessário, ao usuário.

    nota

    Como melhor prática de segurança, é altamente recomendável que você anexe políticas do IAM ao usuário do IAM para restringir o uso das chaves de API do Amazon Bedrock. Para exemplos de políticas de limite de tempo e restrição dos endereços IP que podem usar a chave, consulte Controle o uso de chaves de acesso anexando uma política em linha a um usuário do IAM.

  3. Gere a chave de API Amazon Bedrock de longo prazo enviando uma CreateServiceSpecificCredentialsolicitação com um endpoint do IAM e especificando bedrock.amazonaws.com como o. ServiceName

    • O ServiceApiKeyValue retornado na resposta é sua chave de API Amazon Bedrock de longo prazo.

    • O ServiceSpecificCredentialId retornado na resposta pode ser usado para realizar operações de API relacionadas à chave.

Para saber como gerar uma chave de API Amazon Bedrock de longo prazo, escolha a guia do seu método preferido e siga as etapas:

CLI

Para criar uma chave de API Amazon Bedrock de longo prazo, você usa operações de AWS Identity and Access Management API. Primeiro, verifique se você cumpriu o pré-requisito:

Pré-requisito

Certifique-se de que sua configuração permita que AWS CLI o reconheça automaticamente suas AWS credenciais. Para saber mais, consulte Definindo configurações para o. AWS CLI

Abra um terminal e execute os seguintes comandos:

  1. Criar um usuário do IAM. Você pode substituir o nome por um de sua escolha:

    aws iam create-user --user-name bedrock-api-user

  2. Anexe AmazonBedrockLimitedAccesso ao usuário. Você pode repetir essa etapa com qualquer outra política AWS gerenciada ou personalizada que queira adicionar à chave de API: ARNs 

    aws iam attach-user-policy --user-name bedrock-api-user --policy-arn arn:aws:iam::aws:policy/AmazonBedrockLimitedAccess

  3. Crie a chave de API Amazon Bedrock de longo prazo, ${NUMBER-OF-DAYS} substituindo-a pelo número de dias durante os quais você deseja que a chave dure:

    aws iam create-service-specific-credential \
    --user-name bedrock-api-user \
    --service-name bedrock.amazonaws.com \
    --credential-age-days ${NUMBER-OF-DAYS}
Python

Para criar uma chave de API Amazon Bedrock de longo prazo, você usa operações de AWS Identity and Access Management API. Primeiro, verifique se você cumpriu o pré-requisito:

Pré-requisito

Certifique-se de que sua configuração permita que o Python reconheça automaticamente suas AWS credenciais. Para saber mais, consulte Definindo configurações para o. AWS CLI

Execute o script a seguir para criar um usuário do IAM, anexar permissões para realizar ações do Amazon Bedrock e gerar uma chave de API do Amazon Bedrock de longo prazo para associar ao usuário:

import boto3
from datetime import datetime, timedelta

# Replace with name for your IAM user
username = "bedrock-api-user"
# Add any AWS-managed or custom policies that you want to the user
bedrock_policies = [
    "arn:aws:iam::aws:policy/AmazonBedrockLimitedAccess",        # Limited access
#    "arn:aws:iam::aws:policy/AmazonBedrockMarketplaceAccess",   # Optional: Access to Amazon Bedrock Marketplace actions
]
# Set the key expiration time to a number of your choice
expiration_time_in_days = 30

iam_client = boto3.client("iam")
    
# Create IAM user
user = iam_client.create_iam_user(username)

# Attach policies to user
for policy_arn in bedrock_policies:
    iam_client.attach_managed_policy(username, policy_arn)

# Create long-term Amazon Bedrock API key and return it
service_credentials = iam_client.create_service_specific_credential(
    user_name=username, 
    service_name="bedrock",
    credential_age_days=expiration_time_in_days
) 
api_key = service_credentials["ServiceApiKeyValue"]
print(api_key)

Gere uma chave de API Amazon Bedrock de curto prazo usando uma biblioteca de cliente

As chaves de curto prazo têm as seguintes propriedades:

  • Válido para o menor dos seguintes valores:

    • 12 horas

    • A duração da sessão gerada pelo diretor do IAM usada para gerar a chave.

  • Herde as permissões associadas ao principal usado para gerar a chave.

  • Só pode ser usado na AWS região da qual você o gerou.

Para aplicativos de longa duração, a biblioteca aws-bedrock-token-generatorcliente pode criar novas chaves de API de curto prazo do Amazon Bedrock, conforme necessário, quando as credenciais são atualizadas. Para obter mais informações, consulte Configure a atualização automática de chaves de API Amazon Bedrock de curto prazo.

Pré-requisitos

  • Certifique-se de que o principal do IAM que você usa para gerar a chave esteja configurado com as permissões adequadas para usar o Amazon Bedrock. Para experimentação, você pode anexar a AmazonBedrockLimitedAccesspolítica AWS gerenciada ao principal. Você pode consultar as melhores práticas de segurança no IAM para proteger suas credenciais.

  • Certifique-se de que sua configuração permita que o Python reconheça automaticamente suas AWS credenciais. O método padrão pelo qual as credenciais são recuperadas segue uma hierarquia definida. Você pode ver a hierarquia de um SDK ou ferramenta específica em AWS SDKs e os provedores de credenciais padronizados da Tools.

  • Instale o gerador de tokens Amazon Bedrock. Escolha a guia do seu método preferido e siga as etapas:

Python

Abra um terminal e execute o seguinte comando:

pip install aws-bedrock-token-generator
Javascript

Abra um terminal e execute o seguinte comando:

npm install @aws/bedrock-token-generator
Java

Se você usa o Maven, adicione a seguinte dependência à sua: pom.xml

<dependency>
    <groupId>software.amazon.bedrock</groupId>
    <artifactId>aws-bedrock-token-generator</artifactId>
    <version>1.1.0</version>
</dependency>

Se você usa o Gradle, adicione o seguinte ao seubuild.gradle:

implementation 'software.amazon.bedrock:aws-bedrock-token-generator:1.1.0'
Exemplos

Para ver exemplos de uso do gerador de tokens para gerar uma chave de API Amazon Bedrock de curto prazo com suas credenciais padrão em diferentes idiomas, escolha a guia do seu método preferido e siga as etapas:

Python
from aws_bedrock_token_generator import provide_token

token = provide_token()
print(f"Token: {token}")
Javascript
import { getTokenProvider } from "@aws/bedrock-token-generator";

// Create a token provider that uses default credentials and region providers.
// You can configure it to use other credential providers.
const provideToken = getTokenProvider();

async function example() {
    
  const token = await provideToken();

  // Use the token for API calls. The token has a default expiration of 12 hour.
  // If the expiresInSeconds parameter is specified during token creation, the 
  // expiration can be configured up to a maximum of 12 hours. However, the actual 
  // token validity period will always be the minimum of the requested expiration 
  // time and the AWS credentials' expiry time
  console.log(`Bearer Token: ${token}`);
}
Java
import software.amazon.bedrock.token.BedrockTokenGenerator;

// Credentials and region will be picked up from the default provider chain
BedrockTokenGenerator tokenGenerator = BedrockTokenGenerator.builder().build();
tokenGenerator.getToken();

Para ver mais exemplos de diferentes casos de uso ao gerar tokens, consulte os links a seguir:

Configure a atualização automática de chaves de API Amazon Bedrock de curto prazo

Você pode criar um script com a ajuda do aws-bedrock-token-generator pacote para regenerar programaticamente uma nova chave de curto prazo sempre que a atual expirar. Primeiro, verifique se você cumpriu os pré-requisitos em. Gere uma chave de API Amazon Bedrock de curto prazo usando uma biblioteca de cliente Para ver exemplos de scripts que recuperam um token e fazem uma solicitação Converse, escolha a guia do seu método preferido e siga as etapas:

Python
from aws_bedrock_token_generator import provide_token
import requests

def get_new_token():
    url = "https://bedrock-runtime.us-west-2.amazonaws.com/model/us.anthropic.claude-3-5-haiku-20241022-v1:0/converse"
    payload = {
        "messages": [
            {
                "role": "user",
                "content": [{"text": "Hello"}]
            }
        ]
    }

    # Create a token provider that uses default credentials and region providers.
    # You can configure it to use other credential providers.
    # https://github.com/aws/aws-bedrock-token-generator-python/blob/main/README.md
    # It can be used for each API call as it is inexpensive.
    token = provide_token()

    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {token}"
    }

    response = requests.post(url, headers=headers, json=payload)
    print(response.json())

if __name__ == "__main__":
    get_new_token()
Javascript
import { getTokenProvider } from "@aws/bedrock-token-generator";

// Create a token provider that uses default credentials and region providers.
// You can configure it to use other credential providers.
// https://github.com/aws/aws-bedrock-token-generator-js/blob/main/README.md
// This can be created just once. Use await provideToken() to fetch the token
const provideToken = getTokenProvider();

async function example() {
    const url = "https://bedrock-runtime.us-east-1.amazonaws.com/model/us.anthropic.claude-3-5-haiku-20241022-v1:0/converse";
    const payload = {
        messages: [
            {
                role: "user",
                content: [{ text: "Hello" }]
            }
        ]
    };
    const headers = {
        "Content-Type": "application/json",
        // provideToken retrieves a valid token. It can be used for each API call as it is inexpensive.
        "Authorization": `Bearer ${await provideToken()}`
    };
    await fetch(url, {
        method: 'POST',
        headers: headers,
        body: JSON.stringify(payload)
    })
}
Java
package com.amazon.bedrocktoken;

import software.amazon.bedrock.token.BedrockTokenGenerator;

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class GetNewToken {
    public static void main(String[] args) throws Exception {
        // Use default credentials and region from environment/profile chain
        // Create a token generator that uses default credentials and region providers.
        // You can configure it to use other credential providers.
        // https://github.com/aws/aws-bedrock-token-generator-java/blob/main/README.md
        BedrockTokenGenerator tokenGenerator = BedrockTokenGenerator.builder().build();

        // getToken() retrieves a valid token. It can be used for each API call as it is inexpensive.
        String token = tokenGenerator.getToken();

        String url = "https://bedrock-runtime.us-west-2.amazonaws.com/model/us.anthropic.claude-3-5-haiku-20241022-v1:0/converse";
        String payload = "{\n" +
                "    \"messages\": [\n" +
                "        {\n" +
                "            \"role\": \"user\",\n" +
                "            \"content\": [{ \"text\": \"Hello\" }]\n" +
                "        }\n" +
                "    ]\n" +
                "}";

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("Content-Type", "application/json")
            .header("Authorization", "Bearer " + token)
            .POST(HttpRequest.BodyPublishers.ofString(payload))
            .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}