हैड्स-ऑन लैब — AIP-C01 AWS Certified Generative AI Developer - Professional

अवलोकन

पूर्व-आवश्यकताएं

चरण

1. 1.हमारे टेराफॉर्म संस्करण और AWS क्षेत्र का चयन करें

   मानक शुरुआत। us-east-1 बेडक्रॉक + बेडक्रॉक एजेंट सुविधा की व्यापक उपलब्धता के लिए। प्रदाता संस्करण पिन गैर-परक्राम्य है: aws_bedrockagent_* संसाधनों के लिए ~> 5.60 या बाद के संस्करण की आवश्यकता होती है।

   कॉपी

   terraform {
     required_version = ">= 1.5"
   
     required_providers {
       aws = {
         source  = "hashicorp/aws"
         version = "~> 5.60"
       }
       archive = {
         source  = "hashicorp/archive"
         version = "~> 2.4"
       }
     }
   }
   
   provider "aws" {
     region = "us-east-1"
   
     default_tags {
       tags = {
         Project   = "certlabpro-aip-c01"
         ManagedBy = "terraform"
       }
     }
   }
   
   data "aws_caller_identity" "current" {}
   data "aws_region" "current" {}

2. 2.एजेंट को किसी भी संदर्भ डेटा के लिए एक निजी बकेट दें जिसे वह पढ़ सकता है

   प्रोविज़न:

   • Amazon S3

   अधिकांश उत्पादन बेडक्रॉक एजेंट अंततः S3 से कुछ पढ़ते हैं — नॉलेज-बेस स्रोत दस्तावेज़, JSON टूल परिभाषाएँ, प्रतिक्रिया टेम्पलेट। हम पहले से एक बकेट का प्रावधान करते हैं ताकि हमें बाद में अनुमतियाँ न देनी पड़ें। एन्क्रिप्शन + सार्वजनिक-पहुँच-ब्लॉक डिफ़ॉल्ट AIP-C01 के फ़ाउंडेशन मॉडल इंटीग्रेशन, डेटा मैनेजमेंट और कंप्लायंस डोमेन का हिस्सा हैं।

   AIP-C01 परीक्षा इस बकेट के आसपास एक विशिष्ट अनुपालन पैटर्न का परीक्षण करती है: एक कुंजी के साथ क्लाइंट-साइड एन्क्रिप्शन जिसे एप्लिकेशन नियंत्रित करता है सही उत्तर है जब विनियमन कहता है कि "AWS के पास कभी भी एन्क्रिप्टेड डेटा नहीं होना चाहिए"। अन्य सभी के लिए, SSE-S3 (जो हम यहां करते हैं) पर्याप्त है।

   कॉपी

   resource "aws_s3_bucket" "agent_data" {
     bucket_prefix = "certlabpro-aip-c01-"
   }
   
   resource "aws_s3_bucket_public_access_block" "agent_data" {
     bucket = aws_s3_bucket.agent_data.id
   
     block_public_acls       = true
     block_public_policy     = true
     ignore_public_acls      = true
     restrict_public_buckets = true
   }
   
   resource "aws_s3_bucket_server_side_encryption_configuration" "agent_data" {
     bucket = aws_s3_bucket.agent_data.id
   
     rule {
       apply_server_side_encryption_by_default {
         sse_algorithm = "AES256"
       }
     }
   }

3. 3.सामग्री + PII + निषिद्ध-विषय फ़िल्टर के साथ एक उत्पादन-स्तर का गार्डरेल जोड़ें

   प्रोविज़न:

   • Amazon Bedrock Guardrails

   AIP-C01 का AI सुरक्षा, सुरक्षा और शासन डोमेन (परीक्षा का 20%) AIF-C01 संस्करण की तुलना में बहुत गहरा है। परीक्षा बहु-स्तरीय गार्डरेल संरचना का परीक्षण करती है: उच्च शक्ति पर हानिकारक श्रेणियों के लिए सामग्री फ़िल्टर, PII के लिए संवेदनशील-सूचना नीतियां (ANONYMIZE की AIF-शैली के बजाय BLOCK के साथ — उत्पादन एजेंटों को आमतौर पर हार्ड ब्लॉक की आवश्यकता होती है), और एप्लिकेशन-विशिष्ट निषिद्ध विषयों के लिए विषय नीतियां।

   हम तीनों को कॉन्फ़िगर करते हैं। नीति में निषिद्ध विषय "FinancialAdvice" गैर-वित्तीय चैटबॉट के लिए एक सामान्य उत्पादन गार्डरेल है — क्लाउड 3 भी कभी-कभी स्टॉक टिप्स देने की ओर बढ़ जाएगा जब तक कि आप गार्डरेल को विषयगत बहाव को ब्लॉक करने के लिए न कहें। AIP-C01 परिदृश्य प्रश्नों में इस सटीक संरचना पैटर्न का परीक्षण करता है जहां प्रॉम्प्ट सौम्य होता है लेकिन प्रतिक्रिया नीति से बाहर जा सकती है।

   कॉपी

   resource "aws_bedrock_guardrail" "production" {
     name                      = "certlabpro-aip-c01-production"
     description               = "Production-grade safety rail for the AIP-C01 lab agent."
     blocked_input_messaging   = "I can't help with that request."
     blocked_outputs_messaging = "I can't share that response."
   
     content_policy_config {
       filters_config {
         input_strength  = "HIGH"
         output_strength = "HIGH"
         type            = "HATE"
       }
       filters_config {
         input_strength  = "HIGH"
         output_strength = "HIGH"
         type            = "VIOLENCE"
       }
       filters_config {
         input_strength  = "HIGH"
         output_strength = "HIGH"
         type            = "SEXUAL"
       }
       filters_config {
         input_strength  = "HIGH"
         output_strength = "HIGH"
         type            = "INSULTS"
       }
       filters_config {
         input_strength  = "HIGH"
         output_strength = "HIGH"
         type            = "MISCONDUCT"
       }
     }
   
     sensitive_information_policy_config {
       pii_entities_config {
         action = "BLOCK"
         type   = "EMAIL"
       }
       pii_entities_config {
         action = "BLOCK"
         type   = "PHONE"
       }
       pii_entities_config {
         action = "BLOCK"
         type   = "US_SOCIAL_SECURITY_NUMBER"
       }
       pii_entities_config {
         action = "BLOCK"
         type   = "CREDIT_DEBIT_CARD_NUMBER"
       }
     }
   
     topic_policy_config {
       topics_config {
         name       = "FinancialAdvice"
         definition = "Specific recommendations to buy, sell, or hold financial instruments."
         examples   = ["Should I buy NVDA?", "Is now a good time to sell my Bitcoin?"]
         type       = "DENY"
       }
     }
   }

4. 4.एक स्कोप्ड IAM भूमिका के साथ बेडक्रॉक एजेंट बनाएं

   प्रोविज़न:

   • Amazon Bedrock
   • AWS IAM

   एजेंट एक फ़ाउंडेशन मॉडल, एक सिस्टम प्रॉम्प्ट और (स्टेप 5 में) एक या एक से अधिक एक्शन ग्रुप्स को एक साथ जोड़ता है जो इसकी क्षमताओं का विस्तार करते हैं। हम जिस IAM भूमिका को संलग्न करते हैं, वह एजेंट की एग्जीक्यूशन भूमिका है — इसका उपयोग एजेंट मॉडल को इनवोक करने, नॉलेज बेस से पुनर्प्राप्त करने और एक्शन-ग्रुप लैम्ब्डा को कॉल करने के लिए करता है। AIP-C01 का कार्यान्वयन और एकीकरण डोमेन इस सटीक भूमिका/विश्वास आकार का परीक्षण करता है: bedrock.amazonaws.com प्रिंसिपल के रूप में, विशिष्ट मॉडल ARNs पर bedrock:InvokeModel के लिए स्कोप्ड अनुमतियाँ, और विशिष्ट फ़ंक्शन ARNs पर lambda:InvokeFunction।

   एजेंट का instruction फ़ील्ड सिस्टम प्रॉम्प्ट है — छोटा, कार्रवाई-उन्मुख, एजेंट के उद्देश्य का नामकरण। एजेंट स्तर पर प्रॉम्प्ट इंजीनियरिंग के बारे में AIP-C01 के प्रश्न बिल्कुल इसी का परीक्षण करते हैं: निर्देश स्थायी व्यक्तित्व है; उपयोगकर्ता संदेश प्रति मोड़ बदलता है।

   कॉपी

   resource "aws_iam_role" "agent" {
     name = "certlabpro-aip-c01-agent"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "bedrock.amazonaws.com" }
         Action    = "sts:AssumeRole"
         Condition = {
           StringEquals = {
             "aws:SourceAccount" = data.aws_caller_identity.current.account_id
           }
         }
       }]
     })
   }
   
   resource "aws_iam_role_policy" "agent_invoke_model" {
     name = "invoke-foundation-model"
     role = aws_iam_role.agent.id
   
     policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect = "Allow"
         Action = ["bedrock:InvokeModel", "bedrock:InvokeModelWithResponseStream"]
         Resource = "arn:aws:bedrock:${data.aws_region.current.name}::foundation-model/anthropic.claude-3-haiku-20240307-v1:0"
       }]
     })
   }
   
   resource "aws_bedrockagent_agent" "main" {
     agent_name                  = "certlabpro-aip-c01-agent"
     agent_resource_role_arn     = aws_iam_role.agent.arn
     foundation_model            = "anthropic.claude-3-haiku-20240307-v1:0"
     instruction                 = "You are a helpful assistant for the certlabpro AIP-C01 lab. Answer concisely. When the user asks about the current time, use the get_current_time tool."
     idle_session_ttl_in_seconds = 600
   
     # Attach the guardrail from Step 3. Bedrock evaluates inputs and outputs
     # against the guardrail policy on every model call.
     guardrail_configuration {
       guardrail_identifier = aws_bedrock_guardrail.production.guardrail_id
       guardrail_version    = aws_bedrock_guardrail.production.version
     }
   }

5. 5.एक एक्शन ग्रुप जोड़ें जो एजेंट को लैम्ब्डा टूल को इनवोक करने की सुविधा देता है

   प्रोविज़न:

   • Amazon Bedrock
   • AWS Lambda
   • AWS IAM

   एक्शन ग्रुप्स वह तरीका है जिससे बेडक्रॉक एजेंट्स आपके कोड को कॉल करते हैं। पैटर्न: API स्कीमा को परिभाषित करें (टूल क्या स्वीकार करता है और क्या लौटाता है), उन एक्शन को लागू करने वाले लैम्ब्डा को इंगित करें, और बेडक्रॉक बाकी सब को संभालता है — जब मॉडल तय करता है कि उसे टूल की आवश्यकता है, तो वह संरचित तर्कों के साथ आपके लैम्ब्डा को कॉल करता है और प्रतिक्रिया को बातचीत में वापस भेजता है।

   हम एक न्यूनतम get_current_time एक्शन को OpenAPI 3.0 स्कीमा के साथ परिभाषित करते हैं जिसकी बेडक्रॉक अपेक्षा करता है। लैम्ब्डा कार्यान्वयन जानबूझकर छोटा है — परीक्षा में एकीकरण के आकार का परीक्षण किया जाता है (फ़ंक्शन-कॉलिंग लैम्ब्डा + OpenAPI स्कीमा + बेडक्रॉक इनवोकेशन अनुमति), न कि फ़ंक्शन के आंतरिक तर्क का।

   aws_lambda_permission संसाधन प्रामाणिक AIP-C01 गॉचा है: इसके बिना, लैम्ब्डा का एजेंट का इनवोकेशन AccessDenied प्राप्त करता है, भले ही हर दूसरा भाग सही ढंग से जुड़ा हो। बेडक्रॉक एजेंट → लैम्ब्डा एक बाहरी-सेवा इनवोकेशन पैटर्न है; फ़ंक्शन की संसाधन नीति को स्पष्ट रूप से bedrock.amazonaws.com की अनुमति देनी चाहिए।

   एक्शन ग्रुप्स के साथ, पूर्ण एजेंट आकार पूरा हो जाता है: मॉडल + सिस्टम प्रॉम्प्ट + सुरक्षा गार्डरेल + टूल-कॉलिंग एक्स्टेंसिबिलिटी, सभी एक स्कोप्ड IAM पहचान के तहत। प्रत्येक अतिरिक्त AIP-C01 पैटर्न (नॉलेज बेस पुनर्प्राप्ति, मल्टी-एक्शन एजेंट, पर्यवेक्षक एजेंटों के माध्यम से एजेंट-सहयोग) इस आधार का विस्तार करता है।

   कॉपी

   # ── Lambda tool ───────────────────────────────────────────────
   data "archive_file" "tool" {
     type        = "zip"
     output_path = "${path.module}/build/tool.zip"
   
     source {
       filename = "index.py"
       content  = <<-EOT
         import json
         from datetime import datetime, timezone
         def handler(event, context):
           # Bedrock Agent passes the parsed args under `requestBody` / `parameters`.
           # For a simple no-arg tool, just return the current time.
           now_iso = datetime.now(timezone.utc).isoformat()
           return {
             "messageVersion": "1.0",
             "response": {
               "actionGroup": event.get("actionGroup", ""),
               "apiPath": event.get("apiPath", "/"),
               "httpMethod": event.get("httpMethod", "GET"),
               "httpStatusCode": 200,
               "responseBody": {"application/json": {"body": json.dumps({"current_time_utc": now_iso})}},
             },
           }
       EOT
     }
   }
   
   resource "aws_iam_role" "tool_lambda" {
     name = "certlabpro-aip-c01-tool"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "lambda.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_iam_role_policy_attachment" "tool_logs" {
     role       = aws_iam_role.tool_lambda.name
     policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole"
   }
   
   resource "aws_lambda_function" "tool" {
     function_name    = "certlabpro-aip-c01-tool"
     role             = aws_iam_role.tool_lambda.arn
     runtime          = "python3.12"
     handler          = "index.handler"
     filename         = data.archive_file.tool.output_path
     source_code_hash = data.archive_file.tool.output_base64sha256
     timeout          = 10
   }
   
   resource "aws_lambda_permission" "agent_invoke_tool" {
     statement_id  = "AllowBedrockAgentInvoke"
     action        = "lambda:InvokeFunction"
     function_name = aws_lambda_function.tool.function_name
     principal     = "bedrock.amazonaws.com"
     source_arn    = aws_bedrockagent_agent.main.agent_arn
   }
   
   # Also let the agent invoke the lambda from its execution role.
   resource "aws_iam_role_policy" "agent_invoke_lambda" {
     name = "invoke-tool"
     role = aws_iam_role.agent.id
   
     policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect   = "Allow"
         Action   = "lambda:InvokeFunction"
         Resource = aws_lambda_function.tool.arn
       }]
     })
   }
   
   # ── Action Group ──────────────────────────────────────────────
   resource "aws_bedrockagent_agent_action_group" "time" {
     action_group_name          = "time-tools"
     agent_id                   = aws_bedrockagent_agent.main.agent_id
     agent_version              = "DRAFT"
     description                = "Time-related tool calls for the agent."
     skip_resource_in_use_check = false
   
     action_group_executor {
       lambda = aws_lambda_function.tool.arn
     }
   
     api_schema {
       payload = jsonencode({
         openapi = "3.0.0"
         info    = { title = "Time tools", version = "1.0.0" }
         paths = {
           "/get_current_time" = {
             get = {
               operationId = "get_current_time"
               description = "Returns the current UTC time as an ISO-8601 string."
               responses = {
                 "200" = {
                   description = "Current UTC time"
                   content = {
                     "application/json" = {
                       schema = {
                         type = "object"
                         properties = {
                           current_time_utc = { type = "string", format = "date-time" }
                         }
                       }
                     }
                   }
                 }
               }
             }
           }
         }
       })
     }
   }

क्लीनअप (Cleanup)