हैड्स-ऑन लैब — AIF-C01 AWS Certified AI Practitioner

अवलोकन

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

चरण

1. 1.हमारा Terraform संस्करण और AWS क्षेत्र चुनना

   इससे पहले कि हम कोई संसाधन बनाएं, हमें Terraform को बताना होगा कि हम उसके किस संस्करण की उम्मीद कर रहे हैं और हम किस AWS प्रोवाइडर का उपयोग करेंगे। हम AWS प्रोवाइडर को ~> 5.60 पर पिन करते हैं क्योंकि इस लैब में हमारे द्वारा उपयोग किया जाने वाला प्रत्येक Bedrock-संबंधित संसाधन उसी लाइन में आया था, और हम सब कुछ us-east-1 में डिप्लॉय करते हैं — AWS वहां सबसे पहले फाउंडेशन मॉडल रोल आउट करता है, और अधिकांश AIF-C01 प्रश्न "नवीनतम" सेवा का संदर्भ देते समय us-east-1 की उपलब्धता मानकर चलते हैं।

   शुरू करने के लिए इसे एक नई main.tf फ़ाइल में डालें। इस लैब में आगे आने वाली सभी चीजें इसी फ़ाइल में रहेंगी।

   कॉपी

   terraform {
     required_version = ">= 1.5"
   
     required_providers {
       aws = {
         source  = "hashicorp/aws"
         version = "~> 5.60"
       }
     }
   }
   
   provider "aws" {
     region = "us-east-1"
   }

2. 2.AI सेवाओं को इनपुट पढ़ने और आउटपुट लिखने के लिए एक स्थान देना

   प्रोविज़न:

   • Amazon S3

   प्रत्येक AWS AI सेवा जिसका हम इस लैब में उपयोग करेंगे — आज Bedrock, और ऑडिट लॉगिंग जिसे हम चरण 5 में जोड़ेंगे — Amazon S3 के माध्यम से इनपुट पढ़ती है और आउटपुट लिखती है, इसलिए वास्तविक इन्फ्रास्ट्रक्चर का पहला हिस्सा एक बकेट है। हम बाद के लगभग हर चरण में इस पर वापस आएंगे।

   हम वर्ज़निंग (versioning) को सक्षम करते हैं ताकि किसी दूषित अपलोड को वापस लाया जा सके, सार्वजनिक एक्सेस को ब्लॉक करते हैं (ये ट्रेनिंग इनपुट और मॉडल इनवोकेशन लॉग हैं, न कि वेबसाइट एसेट), और निष्क्रिय अवस्था में AES256 एन्क्रिप्शन (encryption at rest) को सक्षम करते हैं। यह आखिरी बिंदु AIF-C01 के लिए महत्वपूर्ण है — Security, Compliance, and Governance for AI Solutions डोमेन स्पष्ट रूप से यह परीक्षण करता है कि आप किसी भी AI डेटा स्टोर पर डिफ़ॉल्ट रूप से निष्क्रिय अवस्था में एन्क्रिप्शन का उपयोग करते हैं या नहीं।

   कॉपी

   resource "aws_s3_bucket" "ai_data" {
     bucket_prefix = "certlabpro-aif-c01-"
   }
   
   resource "aws_s3_bucket_public_access_block" "ai_data" {
     bucket = aws_s3_bucket.ai_data.id
   
     block_public_acls       = true
     block_public_policy     = true
     ignore_public_acls      = true
     restrict_public_buckets = true
   }
   
   resource "aws_s3_bucket_versioning" "ai_data" {
     bucket = aws_s3_bucket.ai_data.id
   
     versioning_configuration {
       status = "Enabled"
     }
   }
   
   resource "aws_s3_bucket_server_side_encryption_configuration" "ai_data" {
     bucket = aws_s3_bucket.ai_data.id
   
     rule {
       apply_server_side_encryption_by_default {
         sse_algorithm = "AES256"
       }
     }
   }

3. 3.Bedrock को एक पहचान (identity) ग्रहण करने देना ताकि वह वास्तव में हमारी कॉल चला सके

   प्रोविज़न:

   • AWS IAM

   Bedrock अपने दम पर किसी मॉडल को कॉल (invoke) नहीं कर सकता — उसे एक IAM भूमिका (role) की आवश्यकता होती है जिसे वह ग्रहण कर सके। हम एक ट्रस्ट पॉलिसी के साथ एक भूमिका बनाते हैं जो bedrock.amazonaws.com को एकमात्र अनुमत प्रिंसिपल के रूप में नामित करती है, फिर एक न्यूनतम अनुमति नीति (permission policy) संलग्न करते हैं: किसी भी फाउंडेशन मॉडल को लागू करना, और केवल उसी बकेट को पढ़ना/लिखना जिसे हमने चरण 2 में बनाया था।

   इस तरह के न्यूनतम-विशेषाधिकार (Least-privilege) पैटर्न AIF-C01 की एक आवर्ती थीम हैं। ध्यान दें कि हम s3:* प्रदान नहीं करते हैं — केवल दो ऑब्जेक्ट क्रियाएं (actions) जिनकी हमें वास्तव में आवश्यकता है, जो हमारे बकेट के अंदर के ऑब्जेक्ट्स तक सीमित हैं। परीक्षा बहु-विकल्पीय परिदृश्यों में उसी आकार को पहचानने के लिए पुरस्कृत करती है: जब दो उत्तर विकल्प दोनों "काम" करते हैं, तो संकीर्ण (narrower) विकल्प लगभग हमेशा सही होता है।

   कॉपी

   resource "aws_iam_role" "bedrock_caller" {
     name = "certlabpro-aif-c01-bedrock-caller"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "bedrock.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_iam_role_policy" "bedrock_caller" {
     name = "bedrock-invoke"
     role = aws_iam_role.bedrock_caller.id
   
     policy = jsonencode({
       Version = "2012-10-17"
       Statement = [
         {
           Effect = "Allow"
           Action = [
             "bedrock:InvokeModel",
             "bedrock:InvokeModelWithResponseStream",
           ]
           Resource = "arn:aws:bedrock:*::foundation-model/*"
         },
         {
           Effect = "Allow"
           Action = [
             "s3:GetObject",
             "s3:PutObject",
           ]
           Resource = "${aws_s3_bucket.ai_data.arn}/*"
         },
       ]
     })
   }

4. 4.एक सुरक्षा रेल (safety rail) जोड़ना ताकि मॉडल PII या अस्वीकृत विषय उत्सर्जित न कर सके

   प्रोविज़न:

   • Amazon Bedrock Guardrails

   एक Bedrock मॉडल अपने आप में खुशी-खुशी किसी भी चीज़ का उत्तर दे देगा जिसका उत्तर उसका ट्रेनिंग डेटा उसे देने की अनुमति देता है। गार्डरेल्स (Guardrails) प्रत्येक मॉडल कॉल के सामने बैठते हैं और आपके द्वारा उपयोग किए जाने वाले फाउंडेशन मॉडल से स्वतंत्र होकर सामग्री + PII नीतियां लागू करते हैं — जिसका अर्थ है कि एक एकल गार्डरेल Claude, Llama, Titan और भविष्य के किसी भी मॉडल को कवर करता है।

   यहाँ हम दो परतें कॉन्फ़िगर करते हैं। एक कंटेंट फ़िल्टर प्रॉम्प्ट और प्रतिक्रियाओं दोनों में अत्यधिक गंभीर नफरत / हिंसा / यौन सामग्री को ब्लॉक करता है, और एक संवेदनशील-जानकारी नीति (sensitive-information policy) ईमेल, फ़ोन नंबर और यूएस सोशल सिक्योरिटी नंबरों को लीक होने से रोकती है। ये सीधे AIF-C01 के Guidelines for Responsible AI डोमेन से मेल खाते हैं — सामग्री फ़िल्टरिंग और PII हैंडलिंग वहां के दो नामित स्तंभ (pillars) हैं।

   गार्डरेल लागू होने के बाद, चरण 3 में हमारे द्वारा बनाई गई भूमिका (role) एक मॉडल को लागू कर सकती है और परिणाम कॉलर तक पहुँचने से पहले फ़िल्टर हो जाता है।

   कॉपी

   resource "aws_bedrock_guardrail" "safety" {
     name                      = "certlabpro-aif-c01-safety"
     description               = "Default safety rails for the lab."
     blocked_input_messaging   = "I can't help with that."
     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"
       }
     }
   
     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"
       }
     }
   }

5. 5.लॉगिंग चालू करना ताकि हमारे पास प्रत्येक प्रॉम्प्ट और प्रतिक्रिया का ऑडिट ट्रेल हो

   प्रोविज़न:

   • Amazon Bedrock
   • Amazon CloudWatch Logs
   • AWS IAM

   Bedrock इनवोकेशन लॉगिंग खाते और क्षेत्र में प्रत्येक मॉडल कॉल के पूर्ण प्रॉम्प्ट, प्रतिक्रिया और एम्बेडिंग पेलोड को कैप्चर करता है। यह CloudWatch Logs (तदर्थ grep के लिए अच्छा है) और S3 (दीर्घकालिक अवधारण के लिए अच्छा है) में लिखता है — हम दोनों को जोड़ते हैं। जो भूमिका (role) हम संलग्न करते हैं, वह ठीक वही क्रियाएं प्रदान करती है जिनकी Bedrock सेवा को आवश्यकता होती है और कुछ नहीं।

   एक AIF-C01-प्रासंगिक पकड़ (catch) जो जानने योग्य है: इनवोकेशन लॉगिंग एक सिंगलटन है — प्रति खाता प्रति क्षेत्र एक कॉन्फ़िगरेशन। यदि आप इस लैब को us-east-1 में दूसरी बार चलाते हैं तो Terraform किसी बदलाव की रिपोर्ट नहीं करेगा बल्कि मौजूदा कॉन्फ़िगरेशन फिर से बाध्य (re-bound) हो जाएगा। यदि आप कभी भी लॉग डेस्टिनेशन बदलते हैं तो फिर से चलाने से पहले नष्ट (destroy) कर दें।

   लॉगिंग लागू होने के साथ, चरण 3 की भूमिका के विरुद्ध, चरण 4 के गार्डरेल के माध्यम से की जाने वाली प्रत्येक मॉडल कॉल चरण 2 के बकेट में संग्रहीत (archive) हो जाती है। यह पूर्ण ऑडिट श्रृंखला (audit chain) है — ठीक उसी तरह की "मुझे सबूत दिखाओ" वाली कहानी जिसकी परीक्षा आपसे वर्णन करने की उम्मीद करती है।

   कॉपी

   resource "aws_iam_role" "bedrock_logging" {
     name = "certlabpro-aif-c01-bedrock-logging"
   
     assume_role_policy = jsonencode({
       Version = "2012-10-17"
       Statement = [{
         Effect    = "Allow"
         Principal = { Service = "bedrock.amazonaws.com" }
         Action    = "sts:AssumeRole"
       }]
     })
   }
   
   resource "aws_cloudwatch_log_group" "bedrock_invocations" {
     name              = "/aws/bedrock/invocations"
     retention_in_days = 30
   }
   
   resource "aws_iam_role_policy" "bedrock_logging" {
     name = "write-logs-and-s3"
     role = aws_iam_role.bedrock_logging.id
   
     policy = jsonencode({
       Version = "2012-10-17"
       Statement = [
         {
           Effect = "Allow"
           Action = [
             "logs:CreateLogStream",
             "logs:PutLogEvents",
           ]
           Resource = aws_cloudwatch_log_group.bedrock_invocations.arn
         },
         {
           Effect   = "Allow"
           Action   = "s3:PutObject"
           Resource = "${aws_s3_bucket.ai_data.arn}/bedrock-invocations/*"
         },
       ]
     })
   }
   
   resource "aws_bedrock_model_invocation_logging_configuration" "this" {
     logging_config {
       embedding_data_delivery_enabled = true
       image_data_delivery_enabled     = true
       text_data_delivery_enabled      = true
   
       cloudwatch_config {
         log_group_name = aws_cloudwatch_log_group.bedrock_invocations.name
         role_arn       = aws_iam_role.bedrock_logging.arn
       }
   
       s3_config {
         bucket_name = aws_s3_bucket.ai_data.bucket
         key_prefix  = "bedrock-invocations/"
       }
     }
   }

क्लीनअप (Cleanup)