내용으로 건너뛰기
AWS re:Post을(를) 사용하면 다음에 동의하게 됩니다. AWS re:Post 이용 약관
AWS re:Postre:Post
re:Post 소개

AWS CDK를 사용하여 Amazon Bedrock 에이전트를 생성하려면 어떻게 해야 합니까?

5분 분량
0

AWS Cloud Development Kit(AWS CDK)를 사용하여 Amazon BedRock 에이전트를 생성하려고 합니다.

해결 방법

참고: AWS Command Line Interface(AWS CLI) 명령을 실행할 때 오류가 발생하면 AWS CLI의 오류 해결을 참조하십시오. 또한 최신 AWS CLI 버전을 사용하고 있는지 확인하십시오.

일관성, 재현성 및 버전 관리를 보장하기 위해 AWS CDK를 사용하여 Bedrock 에이전트를 코드형 인프라(IaC, infrastructure-as-code)로 정의, 배포 및 관리하십시오.

참고: AWS CDK를 사용하여 Amazon Bedrock 에이전트를 업데이트하려면 AWS CDK를 사용하여 Amazon Bedrock 에이전트를 업데이트하려면 어떻게 해야 합니까?를 참조하십시오.

전제 조건: 다음 전제 조건을 충족하는지 확인합니다.

AWS CDK 프로젝트 생성

Python을 사용하는 AWS CDK 프로젝트를 생성하려면 다음 명령을 실행합니다.

mkdir bedrock-agent-cdk
cd bedrock-agent-cdk
cdk init app --language python

필수 종속성 설치

필수 종속성을 설치하려면 다음 명령을 실행합니다.

pip install aws-cdk-lib constructs

CDK 스택에서 Bedrock Agent 정의

메인 스택 파일 bedrock_agent_cdk/bedrock_agent_cdk_stack.py를 엽니다. 그런 다음 필요에 맞게 구성을 바꾸어 에이전트를 생성합니다.

Amazon Bedrock 에이전트를 생성하려면 메인 스택 파일에 다음 구성을 추가합니다.

from aws_cdk import (
    Stack,
    aws_bedrock as bedrock,
    aws_iam as iam,
    aws_s3 as s3,
    CfnOutput,
)
from constructs import Construct
class BedrockAgentCdkStack(Stack):
    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
        # IAM role for agent
        agent_role = iam.Role(
            self,
            "BedrockAgentRole",
            assumed_by=iam.ServicePrincipal("bedrock.amazonaws.com"),
        )
        agent_role.add_to_policy(
            iam.PolicyStatement(
                actions=["bedrock:InvokeModel"],
                resources=[
                    f"arn:aws:bedrock:{self.region}::foundation-model/anthropic.claude-v2",
                    f"arn:aws:bedrock:{self.region}::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0"
                ],
            )
        )
        # Create Bedrock Agent
        agent = bedrock.CfnAgent(
            self,
            "BedrockAgent",
            agent_name="my-bedrock-agent",
            agent_resource_role_arn=agent_role.role_arn,
            foundation_model="anthropic.claude-3-sonnet-20240229-v1:0",
            instruction="You are an HR agent, helping employees understand HR policies and manage vacation time",
            description="Agent for providing HR assistance to reserve vacation time off",
        )
        # Create alias
        agent_alias = bedrock.CfnAgentAlias(
            self,
            "AgentAlias",
            agent_alias_name="prod",
            agent_id=agent.attr_agent_id,
        )
        CfnOutput(self, "AgentId", value=agent.attr_agent_id)
        CfnOutput(self, "AgentAliasId", value=agent_alias.attr_agent_alias_id)

지식 베이스가 포함된 에이전트를 생성하려면 메인 스택 파일에 다음 구성을 추가합니다.

from aws_cdk import (
    Stack,
    aws_bedrock as bedrock,
    aws_iam as iam,
    aws_s3 as s3,
    CfnOutput,
)
from constructs import Construct
class BedrockAgentCdkStack(Stack):
    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
        # Create S3 bucket for knowledge base data
        kb_bucket = s3.Bucket(
            self,
            "KnowledgeBaseBucket",
            versioned=True,
            encryption=s3.BucketEncryption.S3_MANAGED,
        )
        # IAM role for knowledge base
        kb_role = f"arn:aws:iam::{self.account}:role/service-role/role-name"
        # Create Knowledge Base
        knowledge_base = bedrock.CfnKnowledgeBase(
            self,
            "KnowledgeBase",
            name="my-knowledge-base",
            role_arn=kb_role,
            knowledge_base_configuration=bedrock.CfnKnowledgeBase.KnowledgeBaseConfigurationProperty(
                type="VECTOR",
                vector_knowledge_base_configuration=bedrock.CfnKnowledgeBase.VectorKnowledgeBaseConfigurationProperty(
                    embedding_model_arn=f"arn:aws:bedrock:{self.region}::foundation-model/amazon.titan-embed-text-v2:0"
                ),
            ),
            storage_configuration=bedrock.CfnKnowledgeBase.StorageConfigurationProperty(
                type="OPENSEARCH_SERVERLESS",
                opensearch_serverless_configuration=bedrock.CfnKnowledgeBase.OpenSearchServerlessConfigurationProperty(
                    collection_arn=f"arn:aws:aoss:{self.region}:{self.account}:collection/your-collection-id",
                    vector_index_name="bedrock-knowledge-base-index",
                    field_mapping=bedrock.CfnKnowledgeBase.OpenSearchServerlessFieldMappingProperty(
                        vector_field="bedrock-knowledge-base-default-vector",
                        text_field="AMAZON_BEDROCK_TEXT",
                        metadata_field="AMAZON_BEDROCK_METADATA",
                    ),
                ),
            ),
        )
        # Create Data Source
        data_source = bedrock.CfnDataSource(
            self,
            "DataSource",
            name="s3-data-source",
            knowledge_base_id=knowledge_base.attr_knowledge_base_id,
            data_source_configuration=bedrock.CfnDataSource.DataSourceConfigurationProperty(
                type="S3",
                s3_configuration=bedrock.CfnDataSource.S3DataSourceConfigurationProperty(
                    bucket_arn=kb_bucket.bucket_arn,
                ),
            ),
        )
        # Create Agent with Knowledge Base
        agent_role = iam.Role(
            self,
            "AgentRole",
            assumed_by=iam.ServicePrincipal("bedrock.amazonaws.com"),
        )
        agent_role.add_to_policy(
            iam.PolicyStatement(
                actions=["bedrock:InvokeModel", "bedrock:Retrieve"],
                resources=["*"],
            )
        )
        agent = bedrock.CfnAgent(
            self,
            "Agent",
            agent_name="kb-agent",
            agent_resource_role_arn=agent_role.role_arn,
            foundation_model="anthropic.claude-3-sonnet-20240229-v1:0",
            instruction="You are an assistant with access to a knowledge base. Use it to answer questions accurately.",
            knowledge_bases=[
                bedrock.CfnAgent.AgentKnowledgeBaseProperty(
                    knowledge_base_id=knowledge_base.attr_knowledge_base_id,
                    description="Company documentation knowledge base",
                    knowledge_base_state="ENABLED",
                )
            ],
        )
        # Create alias
        agent_alias = bedrock.CfnAgentAlias(
            self,
            "AgentAlias",
            agent_alias_name="prod",
            agent_id=agent.attr_agent_id,
        )
        CfnOutput(self, "KnowledgeBaseId", value=knowledge_base.attr_knowledge_base_id)
        CfnOutput(self, "BucketName", value=kb_bucket.bucket_name)
        CfnOutput(self, "AgentId", value=agent.attr_agent_id)
        CfnOutput(self, "AgentAliasId", value=agent_alias.attr_agent_alias_id)

참고: 자세한 내용은 지식 베이스를 활용한 에이전트의 응답 생성 증강을 참조하십시오.

작업 그룹이 포함된 에이전트를 생성하려면 메인 스택 파일에 다음 구성을 추가합니다.

from aws_cdk import (
    Stack,
    aws_bedrock as bedrock,
    aws_iam as iam,
    aws_s3 as s3,
    aws_lambda as lambda_,
    CfnOutput,
)
from constructs import Construct
class BedrockAgentCdkStack(Stack):
    def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
        super().__init__(scope, construct_id, **kwargs)
        # Create Lambda function for action group
        action_lambda = lambda_.Function(
            self,
            "AgentActionFunction",
            runtime=lambda_.Runtime.PYTHON_3_11,
            handler="index.handler",
            code=lambda_.Code.from_inline("""
def handler(event, context):
    import json

    action = event.get('actionGroup', '')
    api_path = event.get('apiPath', '')
    parameters = event.get('parameters', [])

    # Process the action
    if api_path == '/getWeather':
        city = next((p['value'] for p in parameters if p['name'] == 'city'), 'Unknown')
        result = {
            'city': city,
            'temperature': 72,
            'condition': 'Sunny'
        }
    else:
        result = {'error': 'Unknown action'}

    return {
        'messageVersion': '1.0',
        'response': {
            'actionGroup': action,
            'apiPath': api_path,
            'httpMethod': event.get('httpMethod', 'GET'),
            'httpStatusCode': 200,
            'responseBody': {
                'application/json': {
                    'body': json.dumps(result)
                }
            }
        }
    }
            """),
        )
        # IAM role for agent
        agent_role = iam.Role(
            self,
            "BedrockAgentRole",
            assumed_by=iam.ServicePrincipal("bedrock.amazonaws.com"),
        )
        agent_role.add_to_policy(
            iam.PolicyStatement(
                actions=["bedrock:InvokeModel"],
                resources=[
                    f"arn:aws:bedrock:{self.region}::foundation-model/anthropic.claude-v2",
                    f"arn:aws:bedrock:{self.region}::foundation-model/anthropic.claude-3-sonnet-20240229-v1:0"
                ],
            )
        )
        # Allow agent to invoke Lambda
        action_lambda.grant_invoke(agent_role)
        # Create Bedrock Agent
        agent = bedrock.CfnAgent(
            self,
            "BedrockAgent",
            agent_name="my-bedrock-agent",
            agent_resource_role_arn=agent_role.role_arn,
            foundation_model="anthropic.claude-3-sonnet-20240229-v1:0",
            instruction="You are a weather assistant that can provide weather information for cities.",
            description="Weather information agent",
        )
        # Create Action Group
        action_group = bedrock.CfnAgent.AgentActionGroupProperty(
            action_group_name="weather-actions",
            description="Actions for getting weather information",
            action_group_state="ENABLED",
            action_group_executor=bedrock.CfnAgent.ActionGroupExecutorProperty(
                lambda_=action_lambda.function_arn
            ),
            api_schema=bedrock.CfnAgent.APISchemaProperty(
                payload="""
{
  "openapi": "3.0.0",
  "info": {
    "title": "Weather API",
    "version": "1.0.0",
    "description": "API for getting weather information"
  },
  "paths": {
    "/getWeather": {
      "get": {
        "summary": "Get weather for a city",
        "description": "Returns current weather information for the specified city",
        "operationId": "getWeather",
        "parameters": [
          {
            "name": "city",
            "in": "query",
            "description": "Name of the city",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful response",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "city": {"type": "string"},
                    "temperature": {"type": "number"},
                    "condition": {"type": "string"}
                  }
                }
              }
            }
          }
        }
      }
    }
  }
}
                """
            ),
        )
        # Update agent with action groups
        agent.action_groups = [action_group]
        # Create alias
        agent_alias = bedrock.CfnAgentAlias(
            self,
            "AgentAlias",
            agent_alias_name="prod",
            agent_id=agent.attr_agent_id,
        )
        CfnOutput(self, "AgentId", value=agent.attr_agent_id)
        CfnOutput(self, "AgentAliasId", value=agent_alias.attr_agent_alias_id)

스택 배포

AWS CDK 스택을 합성하려면 다음 명령을 실행합니다.

cdk synth

AWS CDK 스택을 부트스트랩하려면 다음 명령을 실행합니다.

# Bootstrap CDK (first time only)
cdk bootstrap

스택을 배포하려면 다음 명령을 실행합니다.

cdk deploy

리소스 삭제

스택을 삭제하고 불필요한 리소스를 제거하려면, 다음 명령을 실행하여 스택을 삭제하십시오.

cdk destroy

관련 정보

Amazon Bedrock Agents 런타임

주제
Machine Learning & AIGenerative AI on AWS
태그
Amazon Bedrock
언어
한국어
AWS 공식업데이트됨 7달 전
댓글 없음

관련 콘텐츠