Atelier pratique — AIP-C01 AWS Certified Generative AI Developer - Professional

Présentation

Prérequis

Étapes

1. 1.Choisir notre version de Terraform et notre région AWS

   Ouverture standard. us-east-1 pour la plus large disponibilité des fonctionnalités Bedrock + Bedrock Agent. La version du fournisseur est non-négociable : les ressources aws_bedrockagent_* nécessitent ~> 5.60 ou ultérieur.

   Copier

   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.Donner à l'agent un compartiment privé pour toutes les données de référence qu'il pourrait lire

   Déploie :

   • Amazon S3

   La plupart des Agents Bedrock en production finissent par lire quelque chose depuis S3 — documents source de base de connaissances, définitions d'outils JSON, modèles de réponse. Nous provisionnons un compartiment à l'avance afin de ne pas avoir à configurer les permissions plus tard. Les paramètres par défaut de chiffrement + blocage d'accès public relèvent du domaine Intégration de modèles de fondation, gestion des données et conformité de l'AIP-C01.

   L'examen AIP-C01 teste un modèle de conformité spécifique autour de ce compartiment : le chiffrement côté client avec une clé contrôlée par l'application est la bonne réponse lorsque la réglementation stipule qu'« AWS ne doit jamais avoir accès aux données non chiffrées ». Pour tout le reste, SSE-S3 (ce que nous faisons ici) est suffisant.

   Copier

   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.Ajouter un garde-fou de niveau production avec des filtres de contenu + PII + sujets interdits

   Déploie :

   • Amazon Bedrock Guardrails

   Le domaine Sécurité, sûreté et gouvernance de l'IA de l'AIP-C01 (20 % de l'examen) va beaucoup plus loin que la version AIF-C01. L'examen teste la composition multicouche des garde-fous : les filtres de contenu pour les catégories nuisibles à haute intensité, les politiques d'informations sensibles pour les PII (avec BLOCK plutôt que le style AIF ANONYMIZE — les agents de production ont généralement besoin de blocages stricts), et les politiques thématiques pour les sujets interdits spécifiques à l'application.

   Nous configurons les trois. Le sujet refusé "FinancialAdvice" dans la politique est un garde-fou de production courant pour les chatbots non-financiers — même Claude 3 dérivera parfois vers des conseils boursiers à moins que vous ne demandiez au garde-fou de bloquer la dérive thématique. L'AIP-C01 teste ce modèle de composition exact dans des questions de scénario où l'invite est bénigne mais la réponse pourrait aller à l'encontre de la politique.

   Copier

   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.Créer l'Agent Bedrock avec un rôle IAM délimité

   Déploie :

   • Amazon Bedrock
   • AWS IAM

   L'agent combine un modèle de fondation, une invite système, et (à l'étape 5) un ou plusieurs groupes d'actions qui étendent ses capacités. Le rôle IAM que nous attachons est le rôle d'exécution de l'agent — c'est ce que l'agent utilise pour invoquer des modèles, récupérer des informations des bases de connaissances et appeler des fonctions Lambda de groupe d'actions. Le domaine Implémentation et Intégration de l'AIP-C01 teste cette forme exacte de rôle/confiance : bedrock.amazonaws.com comme principal, des permissions délimitées à bedrock:InvokeModel sur des ARN de modèles spécifiques, et lambda:InvokeFunction sur des ARN de fonctions spécifiques.

   Le champ instruction de l'agent est l'invite système — courte, orientée action, nommant l'objectif de l'agent. Les questions AIP-C01 sur l'ingénierie des invites au niveau de l'agent testent exactement cela : l'instruction est la personnalité persistante ; le message utilisateur change à chaque tour.

   Copier

   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.Ajouter un groupe d'actions qui permet à l'agent d'invoquer un outil Lambda

   Déploie :

   • Amazon Bedrock
   • AWS Lambda
   • AWS IAM

   Les groupes d'actions sont la façon dont les agents Bedrock appellent votre code. Le modèle : définissez le schéma d'API (ce que l'outil accepte et renvoie), pointez vers une fonction Lambda qui implémente les actions, et Bedrock gère le reste — lorsque le modèle décide qu'il a besoin de l'outil, il appelle votre fonction Lambda avec des arguments structurés et réinjecte la réponse dans la conversation.

   Nous définissons une action get_current_time minimale avec le schéma OpenAPI 3.0 attendu par Bedrock. L'implémentation Lambda est intentionnellement minuscule — ce que l'examen teste est la forme de l'intégration (fonction Lambda d'appel de fonction + schéma OpenAPI + permission d'invocation Bedrock), et non la logique interne de la fonction.

   La ressource aws_lambda_permission est le piège classique de l'AIP-C01 : sans elle, l'invocation de la fonction Lambda par l'agent obtient AccessDenied même si toutes les autres pièces sont correctement câblées. Bedrock Agent → Lambda est un modèle d'invocation de service externe ; la politique de ressource de la fonction doit autoriser explicitement bedrock.amazonaws.com.

   Avec les groupes d'actions en place, la forme complète de l'agent est achevée : modèle + invite système + garde-fou de sécurité + extensibilité d'appel d'outils, le tout sous une identité IAM délimitée. Chaque modèle AIP-C01 supplémentaire (récupération de base de connaissances, agents multi-actions, collaboration d'agents via des agents superviseurs) étend cette base.

   Copier

   # ── 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" }
                         }
                       }
                     }
                   }
                 }
               }
             }
           }
         }
       })
     }
   }

Nettoyage