AWS DevOps Agent（Preview）のPrevention（予防）機能を使ってみた #AWSreInvent

#!/bin/bash
# DevOps Agent Prevention Test - Deployment Script (SAM)

set -e

# Configuration
STACK_NAME="${STACK_NAME:-devops-agent-prevention-test}"
REGION="${AWS_REGION:-us-east-1}"
ENVIRONMENT="${ENVIRONMENT:-dev}"

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m'

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_DIR="$(dirname "$SCRIPT_DIR")"

echo -e "${GREEN}=== DevOps Agent Prevention Test - Deployment (SAM) ===${NC}"
echo "Stack Name: ${STACK_NAME}"
echo "Region: ${REGION}"
echo "Environment: ${ENVIRONMENT}"
echo ""

# Check prerequisites
check_prerequisites() {
    echo -e "${YELLOW}Checking prerequisites...${NC}"

    if ! command -v aws &> /dev/null; then
        echo -e "${RED}Error: AWS CLI is not installed${NC}"
        exit 1
    fi

    if ! command -v sam &> /dev/null; then
        echo -e "${RED}Error: AWS SAM CLI is not installed${NC}"
        echo "Install: pip install aws-sam-cli"
        exit 1
    fi

    if ! aws sts get-caller-identity &> /dev/null; then
        echo -e "${RED}Error: AWS credentials not configured${NC}"
        exit 1
    fi

    echo -e "${GREEN}Prerequisites OK${NC}"
    echo ""
}

# Build
build() {
    echo -e "${YELLOW}Building...${NC}"
    cd "$PROJECT_DIR/cloudformation"
    sam build
    echo -e "${GREEN}Build completed${NC}"
    echo ""
}

# Deploy
deploy() {
    echo -e "${YELLOW}Deploying...${NC}"
    cd "$PROJECT_DIR/cloudformation"

    sam deploy \
        --stack-name "$STACK_NAME" \
        --region "$REGION" \
        --capabilities CAPABILITY_IAM CAPABILITY_AUTO_EXPAND \
        --parameter-overrides Environment="$ENVIRONMENT" ProjectName="$STACK_NAME" \
        --resolve-s3 \
        --no-fail-on-empty-changeset

    echo -e "${GREEN}Deployment completed${NC}"
    echo ""
}

# Get outputs
get_outputs() {
    echo -e "${YELLOW}Stack Outputs:${NC}"
    aws cloudformation describe-stacks \
        --stack-name "$STACK_NAME" \
        --region "$REGION" \
        --query 'Stacks[0].Outputs[*].[OutputKey, OutputValue]' \
        --output table
    echo ""
}

# Delete
delete() {
    echo -e "${RED}Deleting stack: ${STACK_NAME}${NC}"
    read -p "Are you sure? (y/N) " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        sam delete --stack-name "$STACK_NAME" --region "$REGION" --no-prompts
        echo -e "${GREEN}Stack deleted${NC}"
    else
        echo "Cancelled"
    fi
}

# Usage
usage() {
    echo "Usage: $0 [command]"
    echo ""
    echo "Commands:"
    echo "  deploy    - Build and deploy (default)"
    echo "  build     - Build only"
    echo "  outputs   - Show stack outputs"
    echo "  delete    - Delete stack"
    echo ""
    echo "Environment variables:"
    echo "  STACK_NAME   - Stack name (default: devops-agent-prevention-test)"
    echo "  AWS_REGION   - Region (default: us-east-1)"
    echo "  ENVIRONMENT  - Environment (default: dev)"
}

# Main
case "${1:-deploy}" in
    deploy)
        check_prerequisites
        build
        deploy
        get_outputs
        ;;
    build)
        check_prerequisites
        build
        ;;
    outputs)
        get_outputs
        ;;
    delete)
        delete
        ;;
    help|--help|-h)
        usage
        ;;
    *)
        echo -e "${RED}Unknown command: $1${NC}"
        usage
        exit 1
        ;;
esac

#!/bin/bash
# DevOps Agent Prevention Test - Incident Generator Script
# This script generates various types of incidents for testing Prevention recommendations

set -e

# Configuration
STACK_NAME="${STACK_NAME:-devops-agent-prevention-test}"
REGION="${AWS_REGION:-ap-northeast-1}"

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

echo -e "${GREEN}=== DevOps Agent Prevention Test - Incident Generator ===${NC}"

# Get API endpoint from CloudFormation outputs
get_api_endpoint() {
    aws cloudformation describe-stacks \
        --stack-name "$STACK_NAME" \
        --region "$REGION" \
        --query 'Stacks[0].Outputs[?OutputKey==`ApiEndpoint`].OutputValue' \
        --output text
}

API_ENDPOINT=$(get_api_endpoint)

if [ -z "$API_ENDPOINT" ]; then
    echo -e "${RED}Error: Could not get API endpoint. Is the stack deployed?${NC}"
    exit 1
fi

echo -e "${GREEN}API Endpoint: ${API_ENDPOINT}${NC}"
echo ""

# Function to make requests and show results
make_request() {
    local method=$1
    local path=$2
    local data=$3
    local description=$4

    echo -e "${YELLOW}>>> ${description}${NC}"
    echo "Request: ${method} ${API_ENDPOINT}${path}"

    if [ "$method" == "GET" ]; then
        response=$(curl -s -w "\n%{http_code}" "${API_ENDPOINT}${path}" 2>/dev/null || echo "error")
    else
        response=$(curl -s -w "\n%{http_code}" -X "${method}" \
            -H "Content-Type: application/json" \
            -d "${data}" \
            "${API_ENDPOINT}${path}" 2>/dev/null || echo "error")
    fi

    body=$(echo "$response" | head -n -1)
    status=$(echo "$response" | tail -n 1)

    if [ "$status" -ge 200 ] && [ "$status" -lt 300 ]; then
        echo -e "${GREEN}Status: ${status}${NC}"
    else
        echo -e "${RED}Status: ${status}${NC}"
    fi
    echo "Response: ${body}"
    echo ""
}

# Generate incidents based on type
generate_errors() {
    echo -e "${RED}=== Generating Error Incidents ===${NC}"

    # Runtime errors
    for i in {1..5}; do
        make_request "GET" "/error?type=runtime" "" "Generating runtime error ($i/5)"
        sleep 1
    done

    # Value errors
    for i in {1..3}; do
        make_request "GET" "/error?type=value" "" "Generating value error ($i/3)"
        sleep 1
    done

    # Key errors
    for i in {1..3}; do
        make_request "GET" "/error?type=key" "" "Generating key error ($i/3)"
        sleep 1
    done
}

generate_timeouts() {
    echo -e "${RED}=== Generating Timeout Incidents ===${NC}"

    # These will cause Lambda timeouts (30s timeout configured)
    for i in {1..3}; do
        echo -e "${YELLOW}>>> Generating timeout incident ($i/3)${NC}"
        echo "Request: GET ${API_ENDPOINT}/timeout?duration=35"
        # Use timeout to avoid waiting too long
        timeout 40 curl -s "${API_ENDPOINT}/timeout?duration=35" 2>/dev/null || echo -e "${RED}Timeout occurred (expected)${NC}"
        echo ""
        sleep 2
    done
}

generate_processing_failures() {
    echo -e "${RED}=== Generating Processing Failures ===${NC}"

    # Processing with high failure rate
    for i in {1..10}; do
        make_request "POST" "/process" '{"data": "test data for processing", "fail_rate": 0.7}' "Processing with 70% failure rate ($i/10)"
        sleep 1
    done
}

generate_slow_responses() {
    echo -e "${YELLOW}=== Generating Slow Response Incidents ===${NC}"

    # Slow processing requests
    for i in {1..5}; do
        make_request "POST" "/process" '{"data": "test data", "slow_rate": 1.0}' "Generating slow response ($i/5)"
    done
}

generate_memory_issues() {
    echo -e "${RED}=== Generating Memory Issues ===${NC}"

    # Memory allocation beyond limit (128MB)
    for i in {1..3}; do
        make_request "GET" "/memory-issue?size_mb=200" "" "Generating memory issue ($i/3)"
        sleep 2
    done
}

# Health check
health_check() {
    echo -e "${GREEN}=== Health Check ===${NC}"
    make_request "GET" "/health" "" "Checking API health"
}

# Show usage
usage() {
    echo "Usage: $0 [command]"
    echo ""
    echo "Commands:"
    echo "  all          - Generate all types of incidents"
    echo "  errors       - Generate error incidents (500 errors)"
    echo "  timeouts     - Generate timeout incidents"
    echo "  failures     - Generate processing failures"
    echo "  slow         - Generate slow response incidents"
    echo "  memory       - Generate memory issues"
    echo "  health       - Check API health"
    echo ""
    echo "Environment variables:"
    echo "  STACK_NAME   - CloudFormation stack name (default: devops-agent-prevention-test)"
    echo "  AWS_REGION   - AWS region (default: ap-northeast-1)"
}

# Main
case "${1:-all}" in
    all)
        health_check
        generate_errors
        generate_processing_failures
        generate_slow_responses
        generate_timeouts
        generate_memory_issues
        echo -e "${GREEN}=== All incidents generated ===${NC}"
        ;;
    errors)
        generate_errors
        ;;
    timeouts)
        generate_timeouts
        ;;
    failures)
        generate_processing_failures
        ;;
    slow)
        generate_slow_responses
        ;;
    memory)
        generate_memory_issues
        ;;
    health)
        health_check
        ;;
    help|--help|-h)
        usage
        ;;
    *)
        echo -e "${RED}Unknown command: $1${NC}"
        usage
        exit 1
        ;;
esac