vi
new
0
Avatar
Lên Cloud cùng Lam @lambuine
45 3 4
Đã đăng vào khoảng 22 giờ trước 9 phút đọc
29

Xây Dựng Hệ Thống Phân Tích Ảnh Thông Minh với AWS Lambda và Amazon Bedrock

Giới Thiệu

Trong thời đại số hóa hiện tại, việc xử lý và phân tích ảnh tự động đã trở thành nhu cầu thiết yếu của nhiều doanh nghiệp. Từ việc nhận diện sản phẩm trong thương mại điện tử, đến việc trích xuất thông tin từ tài liệu, hay phân tích nội dung quảng cáo - tất cả đều yêu cầu khả năng "hiểu" nội dung ảnh một cách thông minh.

Amazon Bedrock Data Automation (BDA) là một dịch vụ mới của AWS cho phép bạn trích xuất thông tin có cấu trúc từ nội dung đa phương thức (multimodal) như ảnh, video, và tài liệu. Khi kết hợp với AWS Lambda, chúng ta có thể tạo ra một hệ thống xử lý ảnh tự động, có khả năng mở rộng và chi phí hiệu quả.

Trong bài viết này, chúng ta sẽ xây dựng một hệ thống hoàn chỉnh để:

  • Tự động phân tích ảnh khi được upload lên S3
  • Trích xuất text, nhận diện logo, và phân loại nội dung ảnh
  • Tạo mô tả chi tiết về nội dung ảnh
  • Lưu trữ kết quả phân tích để sử dụng trong các ứng dụng khác

Kiến Trúc Hệ Thống

Các Dịch Vụ AWS Được Sử Dụng

  1. AWS Lambda: Xử lý sự kiện S3 và điều phối quá trình phân tích
  2. Amazon S3: Lưu trữ ảnh gốc và kết quả phân tích
  3. Amazon Bedrock Data Automation: AI service để phân tích ảnh
  4. Amazon DynamoDB: Lưu trữ metadata và kết quả tìm kiếm
  5. Amazon CloudWatch: Monitoring và logging
  6. AWS IAM: Quản lý quyền truy cập

Bước 1: Chuẩn Bị Môi Trường

1.1 Enable Model Access trong Amazon Bedrock

Mục đích: Kích hoạt quyền truy cập các foundation models cần thiết cho BDA.

⚠️ Quan trọng: Đây là bước bắt buộc trước khi sử dụng Amazon Bedrock Data Automation. Nếu không enable model access, BDA sẽ không thể xử lý ảnh.

Các bước thực hiện:

  1. Mở Amazon Bedrock Console
    • Tìm kiếm Bedrock trong thanh tìm kiếm phía trên
    • Click vào Amazon Bedrock

  1. Truy cập Model Access
    • Ở menu bên trái, click vào Model access
    • Click nút Modify model access

  1. Chọn Models cần thiết:
    • Amazon Models: Chọn tất cả Amazon models
    • Claude Models: Claude 3.5 Haiku, Claude 3 Sonnet, Claude 3.5 Sonnet
    • Cohere Models: Cohere Rerank 3.5

  1. Submit Request
    • Click Next → Submit để request access
    • Chờ approval (hầu hết models được approve ngay lập tức)

1.2 Tạo S3 Bucket

  1. Đăng nhập AWS Console và truy cập dịch vụ S3

  2. Tạo bucket cho ảnh input:

    • Click "Create bucket"
    • Bucket name: your-image-analysis-bucket

    • Uncheck "Block all public access" (nếu cần)
    • Click "Create bucket"

  1. Tạo bucket cho kết quả:
    • Click "Create bucket"

  • Bucket name: your-analysis-results-bucket

  • Click "Create bucket"

1.3 Tạo DynamoDB Table

  1. Truy cập DynamoDB trong AWS Console
  2. Tạo table mới:
  • Click "Create table"

  • Table name: ImageAnalysisResults
  • Partition key: imageId (String)
  • Sort key: timestamp (String)

  • Table settings: "Use default settings"
  • Click "Create table"

1.4 Cấu Hình IAM Role cho Lambda

  1. Truy cập IAM trong AWS Console
  2. Tạo role mới:
    • Click "Roles" → "Create role"

  • Trusted entity type: "AWS service"
  • Use case: "Lambda"
  • Click "Next"

  1. Attach permissions policies:
    • Tìm và chọn các policies sau:
      • AWSLambdaBasicExecutionRole (để Lambda có thể write logs)
      • AmazonS3FullAccess (để đọc/ghi S3)
      • AmazonDynamoDBFullAccess (để lưu kết quả)
      • AmazonBedrockFullAccess (để sử dụng Bedrock BDA)
    • Click "Next"

  1. Hoàn thành tạo role:
    • Role name: ImageAnalysisLambdaRole
    • Description: "Role for Lambda image analysis function"

  • Click "Create role"

1.5 Tạo BDA Project

Mục đích: Tạo BDA project để cấu hình cách xử lý ảnh.

  1. Truy cập Bedrock Data Automation:
    • Trong AWS Console, tìm kiếm và chọn Amazon Bedrock
    • Trong menu bên trái, chọn Data Automation > Set-up Project

  1. Tạo project mới:
    • Click nút Create project

  1. Cấu hình Project:
    • Project name: image-analysis-project
    • Click Create Project

  1. Trong phần Standard output, cấu hình:
    • Chọn Edit
    • Image text recognition: Enable
    • Logos: Enable
    • Bounding Box: Enable
    • Image summarization: Enable
    • IAB taxonomy: Enable

  • Click Save Changes

  1. Review và tạo:
    • Kiểm tra lại cấu hình
    • Lưu lại Project ARN để sử dụng trong Lambda function

Bước 2: Tạo Lambda Function

2.1 Code Lambda Function

Tạo file lambda_function.py:

import json
import boto3
import os
import uuid
import time
from datetime import datetime
from urllib.parse import unquote_plus

# Initialize AWS clients
s3_client = boto3.client('s3')
bda_runtime_client = boto3.client('bedrock-data-automation-runtime')
sts_client = boto3.client('sts')
dynamodb = boto3.resource('dynamodb')

# Get configuration from environment variables
BDA_PROJECT_ARN = os.environ['BDA_PROJECT_ARN']
OUTPUT_BUCKET = os.environ['OUTPUT_BUCKET']
TABLE_NAME = os.environ['TABLE_NAME']

# Get region and account ID dynamically
AWS_REGION = os.environ['AWS_REGION']  # Lambda provides this automatically
account_id = sts_client.get_caller_identity()['Account']

# Construct BDA Profile ARN dynamically
BDA_PROFILE_ARN = f"arn:aws:bedrock:{AWS_REGION}:{account_id}:data-automation-profile/us.data-automation-v1"

def lambda_handler(event, context):
    """
    Lambda function để xử lý ảnh với Bedrock Data Automation
    """
    
    # Debug logging
    print(f"Configuration:")
    print(f"  OUTPUT_BUCKET: {OUTPUT_BUCKET}")
    print(f"  TABLE_NAME: {TABLE_NAME}")
    print(f"  PROJECT_ARN: {BDA_PROJECT_ARN}")
    print(f"  REGION: {AWS_REGION}")
    print(f"  ACCOUNT_ID: {account_id}")
    print(f"  PROFILE_ARN: {BDA_PROFILE_ARN}")
    
    try:
        # Lấy thông tin file từ S3 event
        s3_event = event['Records'][0]['s3']
        input_bucket = s3_event['bucket']['name'].lower()
        # URL decode the key (S3 event has URL-encoded keys)
        image_key = unquote_plus(s3_event['object']['key'])
        
        print(f"Processing image: s3://{input_bucket}/{image_key}")
        
        # Construct S3 URIs
        input_s3_uri = f"s3://{input_bucket}/{image_key}"
        
        # Generate output path with timestamp
        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
        file_name = image_key.split('/')[-1]
        output_prefix = f"processed/{timestamp}_{file_name}"
        output_s3_uri = f"s3://{OUTPUT_BUCKET}/{output_prefix}"
        
        # Tạo unique ID cho ảnh
        image_id = str(uuid.uuid4())
        
        # Xử lý ảnh với BDA
        result = process_image_with_bda(
            input_s3_uri,
            output_s3_uri
        )
        
        # Lưu kết quả vào DynamoDB
        save_results_to_dynamodb(TABLE_NAME, image_id, result, input_s3_uri, output_s3_uri)
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': 'Image processed successfully',
                'imageId': image_id,
                'input': input_s3_uri,
                'output': result.get('output_s3_uri'),
                'invocationArn': result.get('invocationArn')
            })
        }
        
    except Exception as e:
        error_msg = f"Error processing image: {str(e)}"
        print(error_msg)
        return {
            'statusCode': 500,
            'body': json.dumps({
                'error': error_msg
            })
        }

def process_image_with_bda(input_s3_uri, output_s3_uri):
    """
    Xử lý ảnh với Bedrock Data Automation
    """
    print(f"Calling BDA with:")
    print(f"  Input: {input_s3_uri}")
    print(f"  Output: {output_s3_uri}")
    print(f"  Project ARN: {BDA_PROJECT_ARN}")
    print(f"  Profile ARN: {BDA_PROFILE_ARN}")
    
    # Invoke BDA to process the image
    response = bda_runtime_client.invoke_data_automation_async(
        inputConfiguration={
            's3Uri': input_s3_uri
        },
        outputConfiguration={
            's3Uri': output_s3_uri
        },
        dataAutomationConfiguration={
            'dataAutomationProjectArn': BDA_PROJECT_ARN,
            'stage': 'LIVE'  # Changed to LIVE to match document processing
        },
        dataAutomationProfileArn=BDA_PROFILE_ARN
    )
    
    invocation_arn = response['invocationArn']
    print(f"BDA Invocation ARN: {invocation_arn}")
    
    # Wait for processing to complete (with timeout)
    max_wait_time = 240  # 4 minutes
    wait_interval = 10
    elapsed_time = 0
    
    while elapsed_time < max_wait_time:
        status_response = bda_runtime_client.get_data_automation_status(
            invocationArn=invocation_arn
        )
        
        status = status_response['status']
        print(f"Current status: {status}")
        
        if status == 'Success':
            result_s3_uri = status_response['outputConfiguration']['s3Uri']
            print(f"Processing completed successfully!")
            print(f"Results saved to: {result_s3_uri}")
            
            return {
                'invocationArn': invocation_arn,
                'output_s3_uri': result_s3_uri,
                'status': status
            }
        
        elif status in ['ClientError', 'ServiceError']:
            error_msg = f"Processing failed with status: {status}"
            print(error_msg)
            raise Exception(error_msg)
        
        # Wait before checking again
        time.sleep(wait_interval)
        elapsed_time += wait_interval
    
    # Timeout reached
    print(f"Processing still in progress after {max_wait_time} seconds")
    return {
        'invocationArn': invocation_arn,
        'output_s3_uri': output_s3_uri,
        'status': 'Timeout'
    }

def save_results_to_dynamodb(table_name, image_id, result, input_uri, output_uri):
    """
    Lưu kết quả vào DynamoDB
    """
    table = dynamodb.Table(table_name)
    
    item = {
        'imageId': image_id,
        'timestamp': datetime.utcnow().isoformat(),
        'status': result['status'],
        'inputLocation': input_uri,
        'outputLocation': output_uri,
        'invocationArn': result['invocationArn']
    }
    
    table.put_item(Item=item)
    print(f"Saved results to DynamoDB: {image_id}")

2.2 Deploy Lambda Function qua AWS Console

  1. Truy cập Lambda trong AWS Console
  2. Tạo function mới:
    • Click "Create function"

  • Author from scratch
  • Function name: image-analysis-processor
  • Runtime: Python 3.9
  • Architecture: x86_64

  • Execution role: "Use an existing role"
  • Existing role: chọn ImageAnalysisLambdaRole đã tạo ở bước 1
  • Click "Create function"

  1. Cấu hình function:
    • Trong tab "Configuration" → "General configuration"
    • Click "Edit"

  • Timeout: 5 minutes (300 seconds)
  • Memory: 512 MB
  • Click "Save"

  1. Upload code:
    • Trong tab "Code"
    • Xóa code mặc định trong lambda_function.py
    • Copy và paste code từ phần 2.1 vào editor
    • Click "Deploy"

  1. Cấu hình environment variables:
    • Trong tab "Configuration" → "Environment variables"
    • Click "Edit"

  • Thêm các variables sau:
    • Key: INPUT_BUCKET, Value: your-image-analysis-bucket
    • Key: OUTPUT_BUCKET, Value: your-analysis-results-bucket
    • Key: TABLE_NAME, Value: ImageAnalysisResults
    • Key: BDA_PROJECT_ARN, Value: <copy ARN từ bước 1.5>
  • Click "Save"

💡 Tip: Copy Project ARN từ Bedrock Console → Data Automation → Projects → chọn image-analysis-project → copy ARN

Bước 3: Cấu Hình S3 Event Trigger

3.1 Tạo S3 Event Notification

  1. Truy cập S3 trong AWS Console
  2. Cấu hình event notification:
    • Click vào bucket your-image-analysis-bucket
    • Tab "Properties"

  • Scroll xuống "Event notifications"
  • Click "Create event notification"

  1. Cấu hình event:

    • Event notification name: ImageAnalysisTrigger
    • Prefix: để trống (hoặc images/ nếu muốn chỉ xử lý ảnh trong folder này)
    • Suffix: .jpg (sẽ tự động thêm .jpeg và .png sau)
    • Event types: chọn "All object create events"

    • Destination: "Lambda function"
    • Lambda function: chọn image-analysis-processor

  2. Xác nhận cấu hình:

    • Click "Save changes"
    • AWS sẽ tự động thêm permission cho S3 invoke Lambda function

Bước 4: Test Hệ Thống

4.1 Upload Ảnh Test

  1. Upload ảnh qua S3 Console:
    • Truy cập bucket your-image-analysis-bucket
    • Click "Upload"
    • Chọn file ảnh (.jpg, .jpeg, hoặc .png)
    • Click "Upload"

  1. Kiểm tra CloudWatch Logs:
    • Truy cập CloudWatch trong AWS Console
    • Click "Log groups"
    • Tìm log group /aws/lambda/image-analysis-processor
    • Click vào log stream mới nhất để xem logs

4.2 Kiểm Tra Kết Quả

  1. Kiểm tra DynamoDB:
    • Truy cập DynamoDB trong AWS Console
    • Click vào table ImageAnalysisResults
    • Tab "Items" để xem các record đã được tạo

  1. Kiểm tra kết quả trong S3:
    • Truy cập bucket your-analysis-results-bucket
    • Tìm folder results/ chứa kết quả phân tích
    • Download file JSON để xem chi tiết kết quả

Bước 5: Monitoring và Optimization

5.1 CloudWatch Dashboard

  1. Tạo CloudWatch Dashboard:

    • Truy cập CloudWatch trong AWS Console
    • Click "Dashboards" → "Create dashboard"
    • Dashboard name: ImageAnalysisDashboard
    • Click "Create dashboard"

  2. Thêm widgets:

    • Click "Add widget"
    • Chọn "Line chart"
    • Metrics: chọn "AWS/Lambda"
    • Dimensions: FunctionName = image-analysis-processor
    • Metrics to display:
      • Invocations
      • Errors
      • Duration
    • Click "Create widget"

  3. Cấu hình thêm widgets:

    • Thêm "Number" widget cho error rate
    • Thêm "Logs" widget để hiển thị recent logs
    • Click "Save dashboard"

Bước 6: Advanced Features

6.1 Custom Blueprint cho Phân Tích Chuyên Sâu

def create_custom_blueprint(bda_client):
    """
    Tạo custom blueprint cho phân tích ảnh sản phẩm
    """
    blueprint = {
        "class": "Product Image Analysis",
        "description": "Blueprint for analyzing product images in e-commerce",
        "definitions": {
            "ProductInfo": {
                "properties": {
                    "product_category": {
                        "type": "string",
                        "inferenceType": "inferred",
                        "instruction": "What category does this product belong to? (e.g., Electronics, Clothing, Home & Garden)"
                    },
                    "brand_name": {
                        "type": "string", 
                        "inferenceType": "inferred",
                        "instruction": "What brand or manufacturer is this product from?"
                    },
                    "price_visible": {
                        "type": "boolean",
                        "inferenceType": "inferred", 
                        "instruction": "Is there a visible price tag or price information in the image?"
                    },
                    "product_condition": {
                        "type": "string",
                        "inferenceType": "inferred",
                        "instruction": "What is the apparent condition of the product? (New, Used, Damaged, etc.)"
                    }
                }
            }
        },
        "properties": {
            "product_details": {
                "instruction": "Extract detailed product information from this image",
                "$ref": "#/definitions/ProductInfo"
            }
        }
    }
    
    response = bda_client.create_blueprint(
        blueprintName=f'product-analysis-{str(uuid.uuid4())[:8]}',
        type='IMAGE',
        blueprintStage='DEVELOPMENT',
        schema=json.dumps(blueprint)
    )
    
    return response['blueprint']['blueprintArn']

6.2 Batch Processing qua AWS Console

  1. Tạo Lambda function cho batch processing:

    • Tạo function mới: batch-image-processor
    • Runtime: Python 3.9
    • Role: sử dụng cùng role ImageAnalysisLambdaRole

  2. Code cho batch processing:

    import boto3
import json

def lambda_handler(event, context):
    s3_client = boto3.client('s3')
    lambda_client = boto3.client('lambda')
    
    bucket = event['bucket']
    prefix = event.get('prefix', '')
    
    # List tất cả ảnh trong bucket/prefix
    paginator = s3_client.get_paginator('list_objects_v2')
    pages = paginator.paginate(Bucket=bucket, Prefix=prefix)
    
    processed_count = 0
    for page in pages:
        for obj in page.get('Contents', []):
            key = obj['Key']
            if key.lower().endswith(('.jpg', '.jpeg', '.png')):
                # Trigger Lambda cho mỗi ảnh
                lambda_client.invoke(
                    FunctionName='image-analysis-processor',
                    InvocationType='Event',
                    Payload=json.dumps({
                        'Records': [{
                            's3': {
                                'bucket': {'name': bucket},
                                'object': {'key': key}
                            }
                        }]
                    })
                )
                processed_count += 1
    
    return {
        'statusCode': 200,
        'body': f'Triggered processing for {processed_count} images'
    }

  3. Test batch processing:

    • Trong Lambda Console, click "Test"
    • Tạo test event:
    {
  "bucket": "your-image-analysis-bucket",
  "prefix": "batch-images/"
}
    • Click "Test" để chạy batch processing

Kết Luận

Chúng ta đã xây dựng thành công một hệ thống phân tích ảnh tự động sử dụng AWS Lambda và Amazon Bedrock Data Automation. Hệ thống này có thể:

  • Tự động hóa hoàn toàn: Xử lý ảnh ngay khi được upload
  • Mở rộng dễ dàng: Lambda tự động scale theo nhu cầu
  • Chi phí hiệu quả: Chỉ trả tiền khi có ảnh cần xử lý
  • Tích hợp linh hoạt: Kết quả có thể được sử dụng trong các ứng dụng khác

Các Bước Tiếp Theo

  1. Tối ưu hóa performance: Sử dụng Lambda provisioned concurrency cho workloads ổn định
  2. Mở rộng chức năng: Thêm xử lý video, document OCR
  3. Tích hợp AI/ML: Kết hợp với Amazon Rekognition, Amazon Textract
  4. Security: Thêm encryption, VPC endpoints
  5. Monitoring: Thiết lập alerting và logging chi tiết hơn

Với nền tảng này, bạn có thể phát triển các ứng dụng thông minh hơn, từ hệ thống quản lý sản phẩm đến phân tích nội dung marketing, tất cả đều được hỗ trợ bởi sức mạnh của AI và cloud computing.

Bài viết này là một phần của series về AWS Bedrock Data Automation. Để tìm hiểu thêm về các tính năng khác, hãy theo dõi các bài viết tiếp theo.

Amazon Bedrock Amazon S3 Amazon Web Services (AWS) AgenticAi Artificial Intelligence

All rights reserved

Mục lục


Viblo
Hãy đăng ký một tài khoản Viblo để nhận được nhiều bài viết thú vị hơn.
Đăng kí