This is page 96 of 103. Use http://codebase.md/versuscontrol/ai-infrastructure-agent?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .github
│ └── workflows
│ ├── dev-ci.yaml
│ └── release.yaml
├── .gitignore
├── cmd
│ ├── server
│ │ └── main.go
│ ├── tmp
│ │ └── main.go
│ └── web
│ └── main.go
├── config.bedrock.yaml.example
├── config.gemini.yaml.example
├── config.openai.yaml.example
├── config.yaml
├── Dockerfile
├── docs
│ ├── _sidebar.md
│ ├── .nojekyll
│ ├── api-key-setup
│ │ ├── aws-bedrock-nova-setup.md
│ │ ├── gemini-api-setup.md
│ │ └── openai-api-setup.md
│ ├── architecture
│ │ └── architecture-overview.md
│ ├── CNAME
│ ├── docs.html
│ ├── examples
│ │ ├── working-with-ec2-instance.md
│ │ └── working-with-vpc.md
│ ├── getting-started.md
│ ├── images
│ │ ├── advanced-demo.svg
│ │ ├── ai-analysis-planning.png
│ │ ├── ai-execute-planning.png
│ │ ├── ai-infrastructure-agent.svg
│ │ ├── ai-infrastructure-state.png
│ │ ├── core-components.svg
│ │ ├── ec2-00.png
│ │ ├── ec2-01.png
│ │ ├── ec2-02.png
│ │ ├── ec2-03.png
│ │ ├── ec2-04.png
│ │ ├── ec2-05.png
│ │ ├── ec2-06.png
│ │ ├── ec2-07.png
│ │ ├── pattern.879b8d77.svg
│ │ ├── simple-demo.png
│ │ ├── vpc-00.png
│ │ ├── vpc-01.png
│ │ ├── vpc-02.png
│ │ ├── vpc-03.png
│ │ ├── vpc-04.png
│ │ ├── vpc-05.png
│ │ ├── vpc-06.png
│ │ ├── vpc-07.png
│ │ ├── vpc-08.png
│ │ ├── vpc-09.png
│ │ ├── vpc-10.png
│ │ ├── vpc-11.png
│ │ ├── vpc-architecture.svg
│ │ └── web-dashboard.svg
│ ├── index.html
│ ├── installation.md
│ └── README.md
├── go.mod
├── go.sum
├── internal
│ ├── config
│ │ ├── config.go
│ │ └── loader.go
│ └── logging
│ └── logger.go
├── LICENSE
├── pkg
│ ├── adapters
│ │ ├── alb.go
│ │ ├── asg.go
│ │ ├── base.go
│ │ ├── ec2.go
│ │ ├── keypair.go
│ │ ├── rds.go
│ │ ├── security_group.go
│ │ └── vpc.go
│ ├── agent
│ │ ├── agent_capability_extractors.go
│ │ ├── agent_dependency_resolver.go
│ │ ├── agent_factory.go
│ │ ├── agent_json_processing.go
│ │ ├── agent_plan_executor.go
│ │ ├── agent_request_processor.go
│ │ ├── agent_resource_correlation.go
│ │ ├── agent_test.go
│ │ ├── agent_utility_helpers.go
│ │ ├── mcp_communication.go
│ │ ├── mocks
│ │ │ ├── aws_client_mock.go
│ │ │ ├── helpers.go
│ │ │ ├── mcp_integration_test.go
│ │ │ ├── mcp_server_mock.go
│ │ │ ├── state_manager_mock.go
│ │ │ └── validation.go
│ │ ├── react_plan_recovery_engine.go
│ │ ├── react_plan_utility_helpers.go
│ │ ├── resources
│ │ │ ├── field_resolver.go
│ │ │ ├── id_extractor.go
│ │ │ └── pattern_matcher.go
│ │ └── types.go
│ ├── api
│ │ └── server.go
│ ├── aws
│ │ ├── alb.go
│ │ ├── asg.go
│ │ ├── client.go
│ │ ├── ec2.go
│ │ ├── params.go
│ │ ├── rds.go
│ │ ├── security_group.go
│ │ └── vpc.go
│ ├── conflict
│ │ └── resolver.go
│ ├── discovery
│ │ └── scanner.go
│ ├── graph
│ │ ├── analyzer.go
│ │ └── manager.go
│ ├── interfaces
│ │ ├── aws_resource.go
│ │ ├── mcp_tool.go
│ │ └── state_management.go
│ ├── mcp
│ │ ├── resource_definitions.go
│ │ ├── resource_registry.go
│ │ ├── server_integration.go
│ │ ├── server.go
│ │ └── tool_manager.go
│ ├── state
│ │ └── manager.go
│ ├── tools
│ │ ├── alb_tools.go
│ │ ├── ami_tools.go
│ │ ├── asg_tools.go
│ │ ├── ec2_tools.go
│ │ ├── factory.go
│ │ ├── helpers.go
│ │ ├── keypair_tools.go
│ │ ├── networking_tools.go
│ │ ├── rds_tools.go
│ │ ├── registry.go
│ │ ├── security_group_tools.go
│ │ ├── state_tools.go
│ │ ├── vpc_tools.go
│ │ └── zone_tools.go
│ ├── types
│ │ └── mcp.go
│ └── utilities
│ └── helpers.go
├── README.md
├── scripts
│ ├── install.sh
│ └── run-web-ui.sh
├── settings
│ ├── field-mappings-enhanced.yaml
│ ├── resource-extraction-enhanced.yaml
│ ├── resource-patterns-enhanced.yaml
│ └── templates
│ ├── decision-plan-prompt-optimized.txt
│ ├── recovery-prompt-optimized.txt
│ └── tools-execution-context-optimized.txt
└── web
└── build
├── ai-infrastructure-agent.svg
├── asset-manifest.json
├── aws-service-icons
│ ├── .DS_Store
│ ├── analytics
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Athena_16.png
│ │ │ ├── Arch_Amazon-Athena_16.svg
│ │ │ ├── Arch_Amazon-CloudSearch_16.png
│ │ │ ├── Arch_Amazon-CloudSearch_16.svg
│ │ │ ├── Arch_Amazon-Data-Firehose_16.png
│ │ │ ├── Arch_Amazon-Data-Firehose_16.svg
│ │ │ ├── Arch_Amazon-DataZone_16.png
│ │ │ ├── Arch_Amazon-DataZone_16.svg
│ │ │ ├── Arch_Amazon-EMR_16.png
│ │ │ ├── Arch_Amazon-EMR_16.svg
│ │ │ ├── Arch_Amazon-FinSpace_16.png
│ │ │ ├── Arch_Amazon-FinSpace_16.svg
│ │ │ ├── Arch_Amazon-Kinesis_16.png
│ │ │ ├── Arch_Amazon-Kinesis_16.svg
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_16.png
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_16.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_16.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_16.svg
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_16.png
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_16.svg
│ │ │ ├── Arch_Amazon-OpenSearch-Service_16.png
│ │ │ ├── Arch_Amazon-OpenSearch-Service_16.svg
│ │ │ ├── Arch_Amazon-QuickSight_16.png
│ │ │ ├── Arch_Amazon-QuickSight_16.svg
│ │ │ ├── Arch_Amazon-Redshift_16.png
│ │ │ ├── Arch_Amazon-Redshift_16.svg
│ │ │ ├── Arch_Amazon-SageMaker_16.png
│ │ │ ├── Arch_Amazon-SageMaker_16.svg
│ │ │ ├── Arch_AWS-Clean-Rooms_16.png
│ │ │ ├── Arch_AWS-Clean-Rooms_16.svg
│ │ │ ├── Arch_AWS-Data-Exchange_16.png
│ │ │ ├── Arch_AWS-Data-Exchange_16.svg
│ │ │ ├── Arch_AWS-Entity-Resolution_16.png
│ │ │ ├── Arch_AWS-Entity-Resolution_16.svg
│ │ │ ├── Arch_AWS-Glue_16.png
│ │ │ ├── Arch_AWS-Glue_16.svg
│ │ │ ├── Arch_AWS-Glue-DataBrew_16.png
│ │ │ ├── Arch_AWS-Glue-DataBrew_16.svg
│ │ │ ├── Arch_AWS-Lake-Formation_16.png
│ │ │ └── Arch_AWS-Lake-Formation_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Athena_32.png
│ │ │ ├── Arch_Amazon-Athena_32.svg
│ │ │ ├── Arch_Amazon-CloudSearch_32.png
│ │ │ ├── Arch_Amazon-CloudSearch_32.svg
│ │ │ ├── Arch_Amazon-Data-Firehose_32.png
│ │ │ ├── Arch_Amazon-Data-Firehose_32.svg
│ │ │ ├── Arch_Amazon-DataZone_32.png
│ │ │ ├── Arch_Amazon-DataZone_32.svg
│ │ │ ├── Arch_Amazon-EMR_32.png
│ │ │ ├── Arch_Amazon-EMR_32.svg
│ │ │ ├── Arch_Amazon-FinSpace_32.png
│ │ │ ├── Arch_Amazon-FinSpace_32.svg
│ │ │ ├── Arch_Amazon-Kinesis_32.png
│ │ │ ├── Arch_Amazon-Kinesis_32.svg
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_32.png
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_32.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_32.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_32.svg
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_32.png
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_32.svg
│ │ │ ├── Arch_Amazon-OpenSearch-Service_32.png
│ │ │ ├── Arch_Amazon-OpenSearch-Service_32.svg
│ │ │ ├── Arch_Amazon-QuickSight_32.png
│ │ │ ├── Arch_Amazon-QuickSight_32.svg
│ │ │ ├── Arch_Amazon-Redshift_32.png
│ │ │ ├── Arch_Amazon-Redshift_32.svg
│ │ │ ├── Arch_Amazon-SageMaker_32.png
│ │ │ ├── Arch_Amazon-SageMaker_32.svg
│ │ │ ├── Arch_AWS-Clean-Rooms_32.png
│ │ │ ├── Arch_AWS-Clean-Rooms_32.svg
│ │ │ ├── Arch_AWS-Data-Exchange_32.png
│ │ │ ├── Arch_AWS-Data-Exchange_32.svg
│ │ │ ├── Arch_AWS-Entity-Resolution_32.png
│ │ │ ├── Arch_AWS-Entity-Resolution_32.svg
│ │ │ ├── Arch_AWS-Glue_32.png
│ │ │ ├── Arch_AWS-Glue_32.svg
│ │ │ ├── Arch_AWS-Glue-DataBrew_32.png
│ │ │ ├── Arch_AWS-Glue-DataBrew_32.svg
│ │ │ ├── Arch_AWS-Lake-Formation_32.png
│ │ │ └── Arch_AWS-Lake-Formation_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Athena_48.png
│ │ │ ├── Arch_Amazon-Athena_48.svg
│ │ │ ├── Arch_Amazon-CloudSearch_48.png
│ │ │ ├── Arch_Amazon-CloudSearch_48.svg
│ │ │ ├── Arch_Amazon-Data-Firehose_48.png
│ │ │ ├── Arch_Amazon-Data-Firehose_48.svg
│ │ │ ├── Arch_Amazon-DataZone_48.png
│ │ │ ├── Arch_Amazon-DataZone_48.svg
│ │ │ ├── Arch_Amazon-EMR_48.png
│ │ │ ├── Arch_Amazon-EMR_48.svg
│ │ │ ├── Arch_Amazon-FinSpace_48.png
│ │ │ ├── Arch_Amazon-FinSpace_48.svg
│ │ │ ├── Arch_Amazon-Kinesis_48.png
│ │ │ ├── Arch_Amazon-Kinesis_48.svg
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_48.png
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_48.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_48.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_48.svg
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_48.png
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_48.svg
│ │ │ ├── Arch_Amazon-OpenSearch-Service_48.png
│ │ │ ├── Arch_Amazon-OpenSearch-Service_48.svg
│ │ │ ├── Arch_Amazon-QuickSight_48.png
│ │ │ ├── Arch_Amazon-QuickSight_48.svg
│ │ │ ├── Arch_Amazon-Redshift_48.png
│ │ │ ├── Arch_Amazon-Redshift_48.svg
│ │ │ ├── Arch_Amazon-SageMaker_48.png
│ │ │ ├── Arch_Amazon-SageMaker_48.svg
│ │ │ ├── Arch_AWS-Clean-Rooms_48.png
│ │ │ ├── Arch_AWS-Clean-Rooms_48.svg
│ │ │ ├── Arch_AWS-Data-Exchange_48.png
│ │ │ ├── Arch_AWS-Data-Exchange_48.svg
│ │ │ ├── Arch_AWS-Entity-Resolution_48.png
│ │ │ ├── Arch_AWS-Entity-Resolution_48.svg
│ │ │ ├── Arch_AWS-Glue_48.png
│ │ │ ├── Arch_AWS-Glue_48.svg
│ │ │ ├── Arch_AWS-Glue-DataBrew_48.png
│ │ │ ├── Arch_AWS-Glue-DataBrew_48.svg
│ │ │ ├── Arch_AWS-Lake-Formation_48.png
│ │ │ └── Arch_AWS-Lake-Formation_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Athena_64.png
│ │ ├── Arch_Amazon-Athena_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CloudSearch_64.png
│ │ ├── Arch_Amazon-CloudSearch_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Data-Firehose_64.png
│ │ ├── Arch_Amazon-Data-Firehose_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DataZone_64.png
│ │ ├── Arch_Amazon-DataZone_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EMR_64.png
│ │ ├── Arch_Amazon-EMR_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-FinSpace_64.png
│ │ ├── Arch_Amazon-FinSpace_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis_64.png
│ │ ├── Arch_Amazon-Kinesis_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis-Data-Streams_64.png
│ │ ├── Arch_Amazon-Kinesis-Data-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.png
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_64.png
│ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_64.png
│ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-OpenSearch-Service_64.png
│ │ ├── Arch_Amazon-OpenSearch-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-QuickSight_64.png
│ │ ├── Arch_Amazon-QuickSight_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Redshift_64.png
│ │ ├── Arch_Amazon-Redshift_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker_64.png
│ │ ├── Arch_Amazon-SageMaker_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Clean-Rooms_64.png
│ │ ├── Arch_AWS-Clean-Rooms_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Data-Exchange_64.png
│ │ ├── Arch_AWS-Data-Exchange_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Entity-Resolution_64.png
│ │ ├── Arch_AWS-Entity-Resolution_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Glue_64.png
│ │ ├── Arch_AWS-Glue_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Glue-DataBrew_64.png
│ │ ├── Arch_AWS-Glue-DataBrew_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Lake-Formation_64.png
│ │ ├── Arch_AWS-Lake-Formation_64.svg
│ │ └── [email protected]
│ ├── app-integration
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppFlow_16.png
│ │ │ ├── Arch_Amazon-AppFlow_16.svg
│ │ │ ├── Arch_Amazon-EventBridge_16.png
│ │ │ ├── Arch_Amazon-EventBridge_16.svg
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_16.png
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_16.svg
│ │ │ ├── Arch_Amazon-MQ_16.png
│ │ │ ├── Arch_Amazon-MQ_16.svg
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_16.png
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_16.svg
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_16.png
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_16.svg
│ │ │ ├── Arch_AWS-AppSync_16.png
│ │ │ ├── Arch_AWS-AppSync_16.svg
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_16.png
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_16.svg
│ │ │ ├── Arch_AWS-Express-Workflows_16.png
│ │ │ ├── Arch_AWS-Express-Workflows_16.svg
│ │ │ ├── Arch_AWS-Step-Functions_16.png
│ │ │ └── Arch_AWS-Step-Functions_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppFlow_32.png
│ │ │ ├── Arch_Amazon-AppFlow_32.svg
│ │ │ ├── Arch_Amazon-EventBridge_32.png
│ │ │ ├── Arch_Amazon-EventBridge_32.svg
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_32.png
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_32.svg
│ │ │ ├── Arch_Amazon-MQ_32.png
│ │ │ ├── Arch_Amazon-MQ_32.svg
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_32.png
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_32.svg
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_32.png
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_32.svg
│ │ │ ├── Arch_AWS-AppSync_32.png
│ │ │ ├── Arch_AWS-AppSync_32.svg
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_32.png
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_32.svg
│ │ │ ├── Arch_AWS-Express-Workflows_32.png
│ │ │ ├── Arch_AWS-Express-Workflows_32.svg
│ │ │ ├── Arch_AWS-Step-Functions_32.png
│ │ │ └── Arch_AWS-Step-Functions_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppFlow_48.png
│ │ │ ├── Arch_Amazon-AppFlow_48.svg
│ │ │ ├── Arch_Amazon-EventBridge_48.png
│ │ │ ├── Arch_Amazon-EventBridge_48.svg
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_48.png
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_48.svg
│ │ │ ├── Arch_Amazon-MQ_48.png
│ │ │ ├── Arch_Amazon-MQ_48.svg
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_48.png
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_48.svg
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_48.png
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_48.svg
│ │ │ ├── Arch_AWS-AppSync_48.png
│ │ │ ├── Arch_AWS-AppSync_48.svg
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_48.png
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_48.svg
│ │ │ ├── Arch_AWS-Express-Workflows_48.png
│ │ │ ├── Arch_AWS-Express-Workflows_48.svg
│ │ │ ├── Arch_AWS-Step-Functions_48.png
│ │ │ └── Arch_AWS-Step-Functions_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-AppFlow_64.png
│ │ ├── Arch_Amazon-AppFlow_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EventBridge_64.png
│ │ ├── Arch_Amazon-EventBridge_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_64.png
│ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-MQ_64.png
│ │ ├── Arch_Amazon-MQ_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Simple-Notification-Service_64.png
│ │ ├── Arch_Amazon-Simple-Notification-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Simple-Queue-Service_64.png
│ │ ├── Arch_Amazon-Simple-Queue-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-AppSync_64.png
│ │ ├── Arch_AWS-AppSync_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-B2B-Data-Interchange_64.png
│ │ ├── Arch_AWS-B2B-Data-Interchange_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Express-Workflows_64.png
│ │ ├── Arch_AWS-Express-Workflows_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Step-Functions_64.png
│ │ ├── Arch_AWS-Step-Functions_64.svg
│ │ └── [email protected]
│ ├── artificial-intelligence
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_16.png
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_16.svg
│ │ │ ├── Arch_Amazon-Bedrock_16.png
│ │ │ ├── Arch_Amazon-Bedrock_16.svg
│ │ │ ├── Arch_Amazon-CodeGuru_16.png
│ │ │ ├── Arch_Amazon-CodeGuru_16.svg
│ │ │ ├── Arch_Amazon-CodeWhisperer_16.png
│ │ │ ├── Arch_Amazon-CodeWhisperer_16.svg
│ │ │ ├── Arch_Amazon-Comprehend_16.png
│ │ │ ├── Arch_Amazon-Comprehend_16.svg
│ │ │ ├── Arch_Amazon-Comprehend-Medical_16.png
│ │ │ ├── Arch_Amazon-Comprehend-Medical_16.svg
│ │ │ ├── Arch_Amazon-DevOps-Guru_16.png
│ │ │ ├── Arch_Amazon-DevOps-Guru_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Inference_16.png
│ │ │ ├── Arch_Amazon-Elastic-Inference_16.svg
│ │ │ ├── Arch_Amazon-Forecast_16.png
│ │ │ ├── Arch_Amazon-Forecast_16.svg
│ │ │ ├── Arch_Amazon-Fraud-Detector_16.png
│ │ │ ├── Arch_Amazon-Fraud-Detector_16.svg
│ │ │ ├── Arch_Amazon-Kendra_16.png
│ │ │ ├── Arch_Amazon-Kendra_16.svg
│ │ │ ├── Arch_Amazon-Lex_16.png
│ │ │ ├── Arch_Amazon-Lex_16.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_16.png
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_16.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_16.png
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_16.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_16.png
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_16.svg
│ │ │ ├── Arch_Amazon-Monitron_16.png
│ │ │ ├── Arch_Amazon-Monitron_16.svg
│ │ │ ├── Arch_Amazon-Nova_16.png
│ │ │ ├── Arch_Amazon-Nova_16.svg
│ │ │ ├── Arch_Amazon-Personalize_16.png
│ │ │ ├── Arch_Amazon-Personalize_16.svg
│ │ │ ├── Arch_Amazon-Polly_16.png
│ │ │ ├── Arch_Amazon-Polly_16.svg
│ │ │ ├── Arch_Amazon-Q_16.png
│ │ │ ├── Arch_Amazon-Q_16.svg
│ │ │ ├── Arch_Amazon-Rekognition_16.png
│ │ │ ├── Arch_Amazon-Rekognition_16.svg
│ │ │ ├── Arch_Amazon-SageMaker-AI_16.png
│ │ │ ├── Arch_Amazon-SageMaker-AI_16.svg
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_16.png
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_16.svg
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_16.png
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_16.svg
│ │ │ ├── Arch_Amazon-Textract_16.png
│ │ │ ├── Arch_Amazon-Textract_16.svg
│ │ │ ├── Arch_Amazon-Transcribe_16.png
│ │ │ ├── Arch_Amazon-Transcribe_16.svg
│ │ │ ├── Arch_Amazon-Translate_16.png
│ │ │ ├── Arch_Amazon-Translate_16.svg
│ │ │ ├── Arch_Apache-MXNet-on-AWS_16.png
│ │ │ ├── Arch_Apache-MXNet-on-AWS_16.svg
│ │ │ ├── Arch_AWS-App-Studio_16.png
│ │ │ ├── Arch_AWS-App-Studio_16.svg
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_16.png
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_16.svg
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_16.png
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_16.svg
│ │ │ ├── Arch_AWS-DeepComposer_16.png
│ │ │ ├── Arch_AWS-DeepComposer_16.svg
│ │ │ ├── Arch_AWS-DeepRacer_16.png
│ │ │ ├── Arch_AWS-DeepRacer_16.svg
│ │ │ ├── Arch_AWS-HealthImaging_16.png
│ │ │ ├── Arch_AWS-HealthImaging_16.svg
│ │ │ ├── Arch_AWS-HealthLake_16.png
│ │ │ ├── Arch_AWS-HealthLake_16.svg
│ │ │ ├── Arch_AWS-HealthOmics_16.png
│ │ │ ├── Arch_AWS-HealthOmics_16.svg
│ │ │ ├── Arch_AWS-HealthScribe_16.png
│ │ │ ├── Arch_AWS-HealthScribe_16.svg
│ │ │ ├── Arch_AWS-Neuron_16.png
│ │ │ ├── Arch_AWS-Neuron_16.svg
│ │ │ ├── Arch_AWS-Panorama_16.png
│ │ │ ├── Arch_AWS-Panorama_16.svg
│ │ │ ├── Arch_PyTorch-on-AWS_16.png
│ │ │ ├── Arch_PyTorch-on-AWS_16.svg
│ │ │ ├── Arch_TensorFlow-on-AWS_16.png
│ │ │ └── Arch_TensorFlow-on-AWS_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_32.png
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_32.svg
│ │ │ ├── Arch_Amazon-Bedrock_32.png
│ │ │ ├── Arch_Amazon-Bedrock_32.svg
│ │ │ ├── Arch_Amazon-CodeGuru_32.png
│ │ │ ├── Arch_Amazon-CodeGuru_32.svg
│ │ │ ├── Arch_Amazon-CodeWhisperer_32.png
│ │ │ ├── Arch_Amazon-CodeWhisperer_32.svg
│ │ │ ├── Arch_Amazon-Comprehend_32.png
│ │ │ ├── Arch_Amazon-Comprehend_32.svg
│ │ │ ├── Arch_Amazon-Comprehend-Medical_32.png
│ │ │ ├── Arch_Amazon-Comprehend-Medical_32.svg
│ │ │ ├── Arch_Amazon-DevOps-Guru_32.png
│ │ │ ├── Arch_Amazon-DevOps-Guru_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Inference_32.png
│ │ │ ├── Arch_Amazon-Elastic-Inference_32.svg
│ │ │ ├── Arch_Amazon-Forecast_32.png
│ │ │ ├── Arch_Amazon-Forecast_32.svg
│ │ │ ├── Arch_Amazon-Fraud-Detector_32.png
│ │ │ ├── Arch_Amazon-Fraud-Detector_32.svg
│ │ │ ├── Arch_Amazon-Kendra_32.png
│ │ │ ├── Arch_Amazon-Kendra_32.svg
│ │ │ ├── Arch_Amazon-Lex_32.png
│ │ │ ├── Arch_Amazon-Lex_32.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_32.png
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_32.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_32.png
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_32.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_32.png
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_32.svg
│ │ │ ├── Arch_Amazon-Monitron_32.png
│ │ │ ├── Arch_Amazon-Monitron_32.svg
│ │ │ ├── Arch_Amazon-Nova_32.png
│ │ │ ├── Arch_Amazon-Nova_32.svg
│ │ │ ├── Arch_Amazon-Personalize_32.png
│ │ │ ├── Arch_Amazon-Personalize_32.svg
│ │ │ ├── Arch_Amazon-Polly_32.png
│ │ │ ├── Arch_Amazon-Polly_32.svg
│ │ │ ├── Arch_Amazon-Q_32.png
│ │ │ ├── Arch_Amazon-Q_32.svg
│ │ │ ├── Arch_Amazon-Rekognition_32.png
│ │ │ ├── Arch_Amazon-Rekognition_32.svg
│ │ │ ├── Arch_Amazon-SageMaker-AI_32.png
│ │ │ ├── Arch_Amazon-SageMaker-AI_32.svg
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_32.png
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_32.svg
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_32.png
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_32.svg
│ │ │ ├── Arch_Amazon-Textract_32.png
│ │ │ ├── Arch_Amazon-Textract_32.svg
│ │ │ ├── Arch_Amazon-Transcribe_32.png
│ │ │ ├── Arch_Amazon-Transcribe_32.svg
│ │ │ ├── Arch_Amazon-Translate_32.png
│ │ │ ├── Arch_Amazon-Translate_32.svg
│ │ │ ├── Arch_Apache-MXNet-on-AWS_32.png
│ │ │ ├── Arch_Apache-MXNet-on-AWS_32.svg
│ │ │ ├── Arch_AWS-App-Studio_32.png
│ │ │ ├── Arch_AWS-App-Studio_32.svg
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_32.png
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_32.svg
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_32.png
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_32.svg
│ │ │ ├── Arch_AWS-DeepComposer_32.png
│ │ │ ├── Arch_AWS-DeepComposer_32.svg
│ │ │ ├── Arch_AWS-DeepRacer_32.png
│ │ │ ├── Arch_AWS-DeepRacer_32.svg
│ │ │ ├── Arch_AWS-HealthImaging_32.png
│ │ │ ├── Arch_AWS-HealthImaging_32.svg
│ │ │ ├── Arch_AWS-HealthLake_32.png
│ │ │ ├── Arch_AWS-HealthLake_32.svg
│ │ │ ├── Arch_AWS-HealthOmics_32.png
│ │ │ ├── Arch_AWS-HealthOmics_32.svg
│ │ │ ├── Arch_AWS-HealthScribe_32.png
│ │ │ ├── Arch_AWS-HealthScribe_32.svg
│ │ │ ├── Arch_AWS-Neuron_32.png
│ │ │ ├── Arch_AWS-Neuron_32.svg
│ │ │ ├── Arch_AWS-Panorama_32.png
│ │ │ ├── Arch_AWS-Panorama_32.svg
│ │ │ ├── Arch_PyTorch-on-AWS_32.png
│ │ │ ├── Arch_PyTorch-on-AWS_32.svg
│ │ │ ├── Arch_TensorFlow-on-AWS_32.png
│ │ │ └── Arch_TensorFlow-on-AWS_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_48.png
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_48.svg
│ │ │ ├── Arch_Amazon-Bedrock_48.png
│ │ │ ├── Arch_Amazon-Bedrock_48.svg
│ │ │ ├── Arch_Amazon-CodeGuru_48.png
│ │ │ ├── Arch_Amazon-CodeGuru_48.svg
│ │ │ ├── Arch_Amazon-CodeWhisperer_48.png
│ │ │ ├── Arch_Amazon-CodeWhisperer_48.svg
│ │ │ ├── Arch_Amazon-Comprehend_48.png
│ │ │ ├── Arch_Amazon-Comprehend_48.svg
│ │ │ ├── Arch_Amazon-Comprehend-Medical_48.png
│ │ │ ├── Arch_Amazon-Comprehend-Medical_48.svg
│ │ │ ├── Arch_Amazon-DevOps-Guru_48.png
│ │ │ ├── Arch_Amazon-DevOps-Guru_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Inference_48.png
│ │ │ ├── Arch_Amazon-Elastic-Inference_48.svg
│ │ │ ├── Arch_Amazon-Forecast_48.png
│ │ │ ├── Arch_Amazon-Forecast_48.svg
│ │ │ ├── Arch_Amazon-Fraud-Detector_48.png
│ │ │ ├── Arch_Amazon-Fraud-Detector_48.svg
│ │ │ ├── Arch_Amazon-Kendra_48.png
│ │ │ ├── Arch_Amazon-Kendra_48.svg
│ │ │ ├── Arch_Amazon-Lex_48.png
│ │ │ ├── Arch_Amazon-Lex_48.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_48.png
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_48.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_48.png
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_48.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_48.png
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_48.svg
│ │ │ ├── Arch_Amazon-Monitron_48.png
│ │ │ ├── Arch_Amazon-Monitron_48.svg
│ │ │ ├── Arch_Amazon-Nova_48.png
│ │ │ ├── Arch_Amazon-Nova_48.svg
│ │ │ ├── Arch_Amazon-Personalize_48.png
│ │ │ ├── Arch_Amazon-Personalize_48.svg
│ │ │ ├── Arch_Amazon-Polly_48.png
│ │ │ ├── Arch_Amazon-Polly_48.svg
│ │ │ ├── Arch_Amazon-Q_48.png
│ │ │ ├── Arch_Amazon-Q_48.svg
│ │ │ ├── Arch_Amazon-Rekognition_48.png
│ │ │ ├── Arch_Amazon-Rekognition_48.svg
│ │ │ ├── Arch_Amazon-SageMaker-AI_48.png
│ │ │ ├── Arch_Amazon-SageMaker-AI_48.svg
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_48.png
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_48.svg
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_48.png
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_48.svg
│ │ │ ├── Arch_Amazon-Textract_48.png
│ │ │ ├── Arch_Amazon-Textract_48.svg
│ │ │ ├── Arch_Amazon-Transcribe_48.png
│ │ │ ├── Arch_Amazon-Transcribe_48.svg
│ │ │ ├── Arch_Amazon-Translate_48.png
│ │ │ ├── Arch_Amazon-Translate_48.svg
│ │ │ ├── Arch_Apache-MXNet-on-AWS_48.png
│ │ │ ├── Arch_Apache-MXNet-on-AWS_48.svg
│ │ │ ├── Arch_AWS-App-Studio_48.png
│ │ │ ├── Arch_AWS-App-Studio_48.svg
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_48.png
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_48.svg
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_48.png
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_48.svg
│ │ │ ├── Arch_AWS-DeepComposer_48.png
│ │ │ ├── Arch_AWS-DeepComposer_48.svg
│ │ │ ├── Arch_AWS-DeepRacer_48.png
│ │ │ ├── Arch_AWS-DeepRacer_48.svg
│ │ │ ├── Arch_AWS-HealthImaging_48.png
│ │ │ ├── Arch_AWS-HealthImaging_48.svg
│ │ │ ├── Arch_AWS-HealthLake_48.png
│ │ │ ├── Arch_AWS-HealthLake_48.svg
│ │ │ ├── Arch_AWS-HealthOmics_48.png
│ │ │ ├── Arch_AWS-HealthOmics_48.svg
│ │ │ ├── Arch_AWS-HealthScribe_48.png
│ │ │ ├── Arch_AWS-HealthScribe_48.svg
│ │ │ ├── Arch_AWS-Neuron_48.png
│ │ │ ├── Arch_AWS-Neuron_48.svg
│ │ │ ├── Arch_AWS-Panorama_48.png
│ │ │ ├── Arch_AWS-Panorama_48.svg
│ │ │ ├── Arch_PyTorch-on-AWS_48.png
│ │ │ ├── Arch_PyTorch-on-AWS_48.svg
│ │ │ ├── Arch_TensorFlow-on-AWS_48.png
│ │ │ └── Arch_TensorFlow-on-AWS_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Augmented-AI-A2I_64.png
│ │ ├── Arch_Amazon-Augmented-AI-A2I_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Bedrock_64.png
│ │ ├── Arch_Amazon-Bedrock_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CodeGuru_64.png
│ │ ├── Arch_Amazon-CodeGuru_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CodeWhisperer_64.png
│ │ ├── Arch_Amazon-CodeWhisperer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Comprehend_64.png
│ │ ├── Arch_Amazon-Comprehend_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Comprehend-Medical_64.png
│ │ ├── Arch_Amazon-Comprehend-Medical_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DevOps-Guru_64.png
│ │ ├── Arch_Amazon-DevOps-Guru_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Inference_64.png
│ │ ├── Arch_Amazon-Elastic-Inference_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Forecast_64.png
│ │ ├── Arch_Amazon-Forecast_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Fraud-Detector_64.png
│ │ ├── Arch_Amazon-Fraud-Detector_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kendra_64.png
│ │ ├── Arch_Amazon-Kendra_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lex_64.png
│ │ ├── Arch_Amazon-Lex_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lookout-for-Equipment_64.png
│ │ ├── Arch_Amazon-Lookout-for-Equipment_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lookout-for-Metrics_64.png
│ │ ├── Arch_Amazon-Lookout-for-Metrics_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lookout-for-Vision_64.png
│ │ ├── Arch_Amazon-Lookout-for-Vision_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Monitron_64.png
│ │ ├── Arch_Amazon-Monitron_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Nova_64.png
│ │ ├── Arch_Amazon-Nova_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Personalize_64.png
│ │ ├── Arch_Amazon-Personalize_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Polly_64.png
│ │ ├── Arch_Amazon-Polly_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Q_64.png
│ │ ├── Arch_Amazon-Q_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Rekognition_64.png
│ │ ├── Arch_Amazon-Rekognition_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker-AI_64.png
│ │ ├── Arch_Amazon-SageMaker-AI_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker-Ground-Truth_64.png
│ │ ├── Arch_Amazon-SageMaker-Ground-Truth_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker-Studio-Lab_64.png
│ │ ├── Arch_Amazon-SageMaker-Studio-Lab_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Textract_64.png
│ │ ├── Arch_Amazon-Textract_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Transcribe_64.png
│ │ ├── Arch_Amazon-Transcribe_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Translate_64.png
│ │ ├── Arch_Amazon-Translate_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Apache-MXNet-on-AWS_64.png
│ │ ├── Arch_Apache-MXNet-on-AWS_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-App-Studio_64.png
│ │ ├── Arch_AWS-App-Studio_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Deep-Learning-AMIs_64.png
│ │ ├── Arch_AWS-Deep-Learning-AMIs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Deep-Learning-Containers_64.png
│ │ ├── Arch_AWS-Deep-Learning-Containers_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-DeepComposer_64.png
│ │ ├── Arch_AWS-DeepComposer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-DeepRacer_64.png
│ │ ├── Arch_AWS-DeepRacer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthImaging_64.png
│ │ ├── Arch_AWS-HealthImaging_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthLake_64.png
│ │ ├── Arch_AWS-HealthLake_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthOmics_64.png
│ │ ├── Arch_AWS-HealthOmics_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthScribe_64.png
│ │ ├── Arch_AWS-HealthScribe_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Neuron_64.png
│ │ ├── Arch_AWS-Neuron_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Panorama_64.png
│ │ ├── Arch_AWS-Panorama_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_PyTorch-on-AWS_64.png
│ │ ├── Arch_PyTorch-on-AWS_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_TensorFlow-on-AWS_64.png
│ │ ├── Arch_TensorFlow-on-AWS_64.svg
│ │ └── [email protected]
│ ├── blockchain
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Managed-Blockchain_16.png
│ │ │ ├── Arch_Amazon-Managed-Blockchain_16.svg
│ │ │ ├── Arch_Amazon-Quantum-Ledger-Database_16.png
│ │ │ └── Arch_Amazon-Quantum-Ledger-Database_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Managed-Blockchain_32.png
│ │ │ ├── Arch_Amazon-Managed-Blockchain_32.svg
│ │ │ ├── Arch_Amazon-Quantum-Ledger-Database_32.png
│ │ │ └── Arch_Amazon-Quantum-Ledger-Database_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Managed-Blockchain_48.png
│ │ │ ├── Arch_Amazon-Managed-Blockchain_48.svg
│ │ │ ├── Arch_Amazon-Quantum-Ledger-Database_48.png
│ │ │ └── Arch_Amazon-Quantum-Ledger-Database_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Managed-Blockchain_64.png
│ │ ├── Arch_Amazon-Managed-Blockchain_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Quantum-Ledger-Database_64.png
│ │ ├── Arch_Amazon-Quantum-Ledger-Database_64.svg
│ │ └── [email protected]
│ ├── business-applications
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Alexa-For-Business_16.png
│ │ │ ├── Arch_Alexa-For-Business_16.svg
│ │ │ ├── Arch_Amazon-Chime_16.png
│ │ │ ├── Arch_Amazon-Chime_16.svg
│ │ │ ├── Arch_Amazon-Chime-SDK_16.png
│ │ │ ├── Arch_Amazon-Chime-SDK_16.svg
│ │ │ ├── Arch_Amazon-Connect_16.png
│ │ │ ├── Arch_Amazon-Connect_16.svg
│ │ │ ├── Arch_Amazon-Pinpoint_16.png
│ │ │ ├── Arch_Amazon-Pinpoint_16.svg
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_16.png
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_16.svg
│ │ │ ├── Arch_Amazon-Simple-Email-Service_16.png
│ │ │ ├── Arch_Amazon-Simple-Email-Service_16.svg
│ │ │ ├── Arch_Amazon-WorkDocs_16.png
│ │ │ ├── Arch_Amazon-WorkDocs_16.svg
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_16.png
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_16.svg
│ │ │ ├── Arch_Amazon-WorkMail_16.png
│ │ │ ├── Arch_Amazon-WorkMail_16.svg
│ │ │ ├── Arch_AWS-AppFabric_16.png
│ │ │ ├── Arch_AWS-AppFabric_16.svg
│ │ │ ├── Arch_AWS-End-User-Messaging_16.png
│ │ │ ├── Arch_AWS-End-User-Messaging_16.svg
│ │ │ ├── Arch_AWS-Supply-Chain_16.png
│ │ │ ├── Arch_AWS-Supply-Chain_16.svg
│ │ │ ├── Arch_AWS-Wickr_16.png
│ │ │ └── Arch_AWS-Wickr_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Alexa-For-Business_32.png
│ │ │ ├── Arch_Alexa-For-Business_32.svg
│ │ │ ├── Arch_Amazon-Chime_32.png
│ │ │ ├── Arch_Amazon-Chime_32.svg
│ │ │ ├── Arch_Amazon-Chime-SDK_32.png
│ │ │ ├── Arch_Amazon-Chime-SDK_32.svg
│ │ │ ├── Arch_Amazon-Connect_32.png
│ │ │ ├── Arch_Amazon-Connect_32.svg
│ │ │ ├── Arch_Amazon-Pinpoint_32.png
│ │ │ ├── Arch_Amazon-Pinpoint_32.svg
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_32.png
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_32.svg
│ │ │ ├── Arch_Amazon-Simple-Email-Service_32.png
│ │ │ ├── Arch_Amazon-Simple-Email-Service_32.svg
│ │ │ ├── Arch_Amazon-WorkDocs_32.png
│ │ │ ├── Arch_Amazon-WorkDocs_32.svg
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_32.png
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_32.svg
│ │ │ ├── Arch_Amazon-WorkMail_32.png
│ │ │ ├── Arch_Amazon-WorkMail_32.svg
│ │ │ ├── Arch_AWS-AppFabric_32.png
│ │ │ ├── Arch_AWS-AppFabric_32.svg
│ │ │ ├── Arch_AWS-End-User-Messaging_32.png
│ │ │ ├── Arch_AWS-End-User-Messaging_32.svg
│ │ │ ├── Arch_AWS-Supply-Chain_32.png
│ │ │ ├── Arch_AWS-Supply-Chain_32.svg
│ │ │ ├── Arch_AWS-Wickr_32.png
│ │ │ └── Arch_AWS-Wickr_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Alexa-For-Business_48.png
│ │ │ ├── Arch_Alexa-For-Business_48.svg
│ │ │ ├── Arch_Amazon-Chime_48.png
│ │ │ ├── Arch_Amazon-Chime_48.svg
│ │ │ ├── Arch_Amazon-Chime-SDK_48.png
│ │ │ ├── Arch_Amazon-Chime-SDK_48.svg
│ │ │ ├── Arch_Amazon-Connect_48.png
│ │ │ ├── Arch_Amazon-Connect_48.svg
│ │ │ ├── Arch_Amazon-Pinpoint_48.png
│ │ │ ├── Arch_Amazon-Pinpoint_48.svg
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_48.png
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_48.svg
│ │ │ ├── Arch_Amazon-Simple-Email-Service_48.png
│ │ │ ├── Arch_Amazon-Simple-Email-Service_48.svg
│ │ │ ├── Arch_Amazon-WorkDocs_48.png
│ │ │ ├── Arch_Amazon-WorkDocs_48.svg
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_48.png
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_48.svg
│ │ │ ├── Arch_Amazon-WorkMail_48.png
│ │ │ ├── Arch_Amazon-WorkMail_48.svg
│ │ │ ├── Arch_AWS-AppFabric_48.png
│ │ │ ├── Arch_AWS-AppFabric_48.svg
│ │ │ ├── Arch_AWS-End-User-Messaging_48.png
│ │ │ ├── Arch_AWS-End-User-Messaging_48.svg
│ │ │ ├── Arch_AWS-Supply-Chain_48.png
│ │ │ ├── Arch_AWS-Supply-Chain_48.svg
│ │ │ ├── Arch_AWS-Wickr_48.png
│ │ │ └── Arch_AWS-Wickr_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Alexa-For-Business_64.png
│ │ ├── Arch_Alexa-For-Business_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Chime_64.png
│ │ ├── Arch_Amazon-Chime_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Chime-SDK_64.png
│ │ ├── Arch_Amazon-Chime-SDK_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Connect_64.png
│ │ ├── Arch_Amazon-Connect_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Pinpoint_64.png
│ │ ├── Arch_Amazon-Pinpoint_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Pinpoint-APIs_64.png
│ │ ├── Arch_Amazon-Pinpoint-APIs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Simple-Email-Service_64.png
│ │ ├── Arch_Amazon-Simple-Email-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkDocs_64.png
│ │ ├── Arch_Amazon-WorkDocs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkDocs-SDK_64.png
│ │ ├── Arch_Amazon-WorkDocs-SDK_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkMail_64.png
│ │ ├── Arch_Amazon-WorkMail_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-AppFabric_64.png
│ │ ├── Arch_AWS-AppFabric_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-End-User-Messaging_64.png
│ │ ├── Arch_AWS-End-User-Messaging_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Supply-Chain_64.png
│ │ ├── Arch_AWS-Supply-Chain_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Wickr_64.png
│ │ ├── Arch_AWS-Wickr_64.svg
│ │ └── [email protected]
│ ├── cloud-financial
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Billing-Conductor_16.png
│ │ │ ├── Arch_AWS-Billing-Conductor_16.svg
│ │ │ ├── Arch_AWS-Budgets_16.png
│ │ │ ├── Arch_AWS-Budgets_16.svg
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_16.png
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_16.svg
│ │ │ ├── Arch_AWS-Cost-Explorer_16.png
│ │ │ ├── Arch_AWS-Cost-Explorer_16.svg
│ │ │ ├── Arch_Reserved-Instance-Reporting_16.png
│ │ │ ├── Arch_Reserved-Instance-Reporting_16.svg
│ │ │ ├── Arch_Savings-Plans_16.png
│ │ │ └── Arch_Savings-Plans_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Billing-Conductor_32.png
│ │ │ ├── Arch_AWS-Billing-Conductor_32.svg
│ │ │ ├── Arch_AWS-Budgets_32.png
│ │ │ ├── Arch_AWS-Budgets_32.svg
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_32.png
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_32.svg
│ │ │ ├── Arch_AWS-Cost-Explorer_32.png
│ │ │ ├── Arch_AWS-Cost-Explorer_32.svg
│ │ │ ├── Arch_Reserved-Instance-Reporting_32.png
│ │ │ ├── Arch_Reserved-Instance-Reporting_32.svg
│ │ │ ├── Arch_Savings-Plans_32.png
│ │ │ └── Arch_Savings-Plans_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Billing-Conductor_48.png
│ │ │ ├── Arch_AWS-Billing-Conductor_48.svg
│ │ │ ├── Arch_AWS-Budgets_48.png
│ │ │ ├── Arch_AWS-Budgets_48.svg
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_48.png
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_48.svg
│ │ │ ├── Arch_AWS-Cost-Explorer_48.png
│ │ │ ├── Arch_AWS-Cost-Explorer_48.svg
│ │ │ ├── Arch_Reserved-Instance-Reporting_48.png
│ │ │ ├── Arch_Reserved-Instance-Reporting_48.svg
│ │ │ ├── Arch_Savings-Plans_48.png
│ │ │ └── Arch_Savings-Plans_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_AWS-Billing-Conductor_64.png
│ │ ├── Arch_AWS-Billing-Conductor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Budgets_64.png
│ │ ├── Arch_AWS-Budgets_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cost-and-Usage-Report_64.png
│ │ ├── Arch_AWS-Cost-and-Usage-Report_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cost-Explorer_64.png
│ │ ├── Arch_AWS-Cost-Explorer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Reserved-Instance-Reporting_64.png
│ │ ├── Arch_Reserved-Instance-Reporting_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Savings-Plans_64.png
│ │ ├── Arch_Savings-Plans_64.svg
│ │ └── [email protected]
│ ├── compute
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-DCV_16.png
│ │ │ ├── Arch_Amazon-DCV_16.svg
│ │ │ ├── Arch_Amazon-EC2_16.png
│ │ │ ├── Arch_Amazon-EC2_16.svg
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_16.png
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_16.svg
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_16.png
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_16.svg
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_16.png
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_16.svg
│ │ │ ├── Arch_Amazon-Lightsail_16.png
│ │ │ ├── Arch_Amazon-Lightsail_16.svg
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_16.png
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_16.svg
│ │ │ ├── Arch_AWS-App-Runner_16.png
│ │ │ ├── Arch_AWS-App-Runner_16.svg
│ │ │ ├── Arch_AWS-Batch_16.png
│ │ │ ├── Arch_AWS-Batch_16.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.svg
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_16.png
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_16.svg
│ │ │ ├── Arch_AWS-Lambda_16.png
│ │ │ ├── Arch_AWS-Lambda_16.svg
│ │ │ ├── Arch_AWS-Local-Zones_16.png
│ │ │ ├── Arch_AWS-Local-Zones_16.svg
│ │ │ ├── Arch_AWS-Nitro-Enclaves_16.png
│ │ │ ├── Arch_AWS-Nitro-Enclaves_16.svg
│ │ │ ├── Arch_AWS-Outposts-family_16.png
│ │ │ ├── Arch_AWS-Outposts-family_16.svg
│ │ │ ├── Arch_AWS-Outposts-rack_16.png
│ │ │ ├── Arch_AWS-Outposts-rack_16.svg
│ │ │ ├── Arch_AWS-Outposts-servers_16.png
│ │ │ ├── Arch_AWS-Outposts-servers_16.svg
│ │ │ ├── Arch_AWS-Parallel-Cluster_16.png
│ │ │ ├── Arch_AWS-Parallel-Cluster_16.svg
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_16.png
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_16.svg
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_16.png
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_16.svg
│ │ │ ├── Arch_AWS-SimSpace-Weaver_16.png
│ │ │ ├── Arch_AWS-SimSpace-Weaver_16.svg
│ │ │ ├── Arch_AWS-Wavelength_16.png
│ │ │ ├── Arch_AWS-Wavelength_16.svg
│ │ │ ├── Arch_Bottlerocket_16.png
│ │ │ ├── Arch_Bottlerocket_16.svg
│ │ │ ├── Arch_Elastic-Fabric-Adapter_16.png
│ │ │ ├── Arch_Elastic-Fabric-Adapter_16.svg
│ │ │ ├── Arch_NICE-EnginFrame_16.png
│ │ │ └── Arch_NICE-EnginFrame_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-DCV_32.png
│ │ │ ├── Arch_Amazon-DCV_32.svg
│ │ │ ├── Arch_Amazon-EC2_32.png
│ │ │ ├── Arch_Amazon-EC2_32.svg
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_32.png
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_32.svg
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_32.png
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_32.svg
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_32.png
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_32.svg
│ │ │ ├── Arch_Amazon-Lightsail_32.png
│ │ │ ├── Arch_Amazon-Lightsail_32.svg
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_32.png
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_32.svg
│ │ │ ├── Arch_AWS-App-Runner_32.png
│ │ │ ├── Arch_AWS-App-Runner_32.svg
│ │ │ ├── Arch_AWS-Batch_32.png
│ │ │ ├── Arch_AWS-Batch_32.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.svg
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_32.png
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_32.svg
│ │ │ ├── Arch_AWS-Lambda_32.png
│ │ │ ├── Arch_AWS-Lambda_32.svg
│ │ │ ├── Arch_AWS-Local-Zones_32.png
│ │ │ ├── Arch_AWS-Local-Zones_32.svg
│ │ │ ├── Arch_AWS-Nitro-Enclaves_32.png
│ │ │ ├── Arch_AWS-Nitro-Enclaves_32.svg
│ │ │ ├── Arch_AWS-Outposts-family_32.png
│ │ │ ├── Arch_AWS-Outposts-family_32.svg
│ │ │ ├── Arch_AWS-Outposts-rack_32.png
│ │ │ ├── Arch_AWS-Outposts-rack_32.svg
│ │ │ ├── Arch_AWS-Outposts-servers_32.png
│ │ │ ├── Arch_AWS-Outposts-servers_32.svg
│ │ │ ├── Arch_AWS-Parallel-Cluster_32.png
│ │ │ ├── Arch_AWS-Parallel-Cluster_32.svg
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_32.png
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_32.svg
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_32.png
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_32.svg
│ │ │ ├── Arch_AWS-SimSpace-Weaver_32.png
│ │ │ ├── Arch_AWS-SimSpace-Weaver_32.svg
│ │ │ ├── Arch_AWS-Wavelength_32.png
│ │ │ ├── Arch_AWS-Wavelength_32.svg
│ │ │ ├── Arch_Bottlerocket_32.png
│ │ │ ├── Arch_Bottlerocket_32.svg
│ │ │ ├── Arch_Elastic-Fabric-Adapter_32.png
│ │ │ ├── Arch_Elastic-Fabric-Adapter_32.svg
│ │ │ ├── Arch_NICE-EnginFrame_32.png
│ │ │ └── Arch_NICE-EnginFrame_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-DCV_48.png
│ │ │ ├── Arch_Amazon-DCV_48.svg
│ │ │ ├── Arch_Amazon-EC2_48.png
│ │ │ ├── Arch_Amazon-EC2_48.svg
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_48.png
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_48.svg
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_48.png
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_48.svg
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_48.png
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_48.svg
│ │ │ ├── Arch_Amazon-Lightsail_48.png
│ │ │ ├── Arch_Amazon-Lightsail_48.svg
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_48.png
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_48.svg
│ │ │ ├── Arch_AWS-App-Runner_48.png
│ │ │ ├── Arch_AWS-App-Runner_48.svg
│ │ │ ├── Arch_AWS-Batch_48.png
│ │ │ ├── Arch_AWS-Batch_48.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.svg
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_48.png
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_48.svg
│ │ │ ├── Arch_AWS-Lambda_48.png
│ │ │ ├── Arch_AWS-Lambda_48.svg
│ │ │ ├── Arch_AWS-Local-Zones_48.png
│ │ │ ├── Arch_AWS-Local-Zones_48.svg
│ │ │ ├── Arch_AWS-Nitro-Enclaves_48.png
│ │ │ ├── Arch_AWS-Nitro-Enclaves_48.svg
│ │ │ ├── Arch_AWS-Outposts-family_48.png
│ │ │ ├── Arch_AWS-Outposts-family_48.svg
│ │ │ ├── Arch_AWS-Outposts-rack_48.png
│ │ │ ├── Arch_AWS-Outposts-rack_48.svg
│ │ │ ├── Arch_AWS-Outposts-servers_48.png
│ │ │ ├── Arch_AWS-Outposts-servers_48.svg
│ │ │ ├── Arch_AWS-Parallel-Cluster_48.png
│ │ │ ├── Arch_AWS-Parallel-Cluster_48.svg
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_48.png
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_48.svg
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_48.png
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_48.svg
│ │ │ ├── Arch_AWS-SimSpace-Weaver_48.png
│ │ │ ├── Arch_AWS-SimSpace-Weaver_48.svg
│ │ │ ├── Arch_AWS-Wavelength_48.png
│ │ │ ├── Arch_AWS-Wavelength_48.svg
│ │ │ ├── Arch_Bottlerocket_48.png
│ │ │ ├── Arch_Bottlerocket_48.svg
│ │ │ ├── Arch_Elastic-Fabric-Adapter_48.png
│ │ │ ├── Arch_Elastic-Fabric-Adapter_48.svg
│ │ │ ├── Arch_NICE-EnginFrame_48.png
│ │ │ └── Arch_NICE-EnginFrame_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-DCV_64.png
│ │ ├── Arch_Amazon-DCV_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EC2_64.png
│ │ ├── Arch_Amazon-EC2_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EC2-Auto-Scaling_64.png
│ │ ├── Arch_Amazon-EC2-Auto-Scaling_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EC2-Image-Builder_64.png
│ │ ├── Arch_Amazon-EC2-Image-Builder_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-VMware-Service_64.png
│ │ ├── Arch_Amazon-Elastic-VMware-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lightsail_64.png
│ │ ├── Arch_Amazon-Lightsail_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lightsail-for-Research_64.png
│ │ ├── Arch_Amazon-Lightsail-for-Research_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-App-Runner_64.png
│ │ ├── Arch_AWS-App-Runner_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Batch_64.png
│ │ ├── Arch_AWS-Batch_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Compute-Optimizer_64.png
│ │ ├── Arch_AWS-Compute-Optimizer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elastic-Beanstalk_64.png
│ │ ├── Arch_AWS-Elastic-Beanstalk_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Lambda_64.png
│ │ ├── Arch_AWS-Lambda_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Local-Zones_64.png
│ │ ├── Arch_AWS-Local-Zones_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Nitro-Enclaves_64.png
│ │ ├── Arch_AWS-Nitro-Enclaves_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Outposts-family_64.png
│ │ ├── Arch_AWS-Outposts-family_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Outposts-rack_64.png
│ │ ├── Arch_AWS-Outposts-rack_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Outposts-servers_64.png
│ │ ├── Arch_AWS-Outposts-servers_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Parallel-Cluster_64.png
│ │ ├── Arch_AWS-Parallel-Cluster_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Parallel-Computing-Service_64.png
│ │ ├── Arch_AWS-Parallel-Computing-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Serverless-Application-Repository_64.png
│ │ ├── Arch_AWS-Serverless-Application-Repository_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-SimSpace-Weaver_64.png
│ │ ├── Arch_AWS-SimSpace-Weaver_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Wavelength_64.png
│ │ ├── Arch_AWS-Wavelength_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Bottlerocket_64.png
│ │ ├── Arch_Bottlerocket_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Elastic-Fabric-Adapter_64.png
│ │ ├── Arch_Elastic-Fabric-Adapter_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_NICE-EnginFrame_64.png
│ │ ├── Arch_NICE-EnginFrame_64.svg
│ │ └── [email protected]
│ ├── containers
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-ECS-Anywhere_16.png
│ │ │ ├── Arch_Amazon-ECS-Anywhere_16.svg
│ │ │ ├── Arch_Amazon-EKS-Anywhere_16.png
│ │ │ ├── Arch_Amazon-EKS-Anywhere_16.svg
│ │ │ ├── Arch_Amazon-EKS-Cloud_16.png
│ │ │ ├── Arch_Amazon-EKS-Cloud_16.svg
│ │ │ ├── Arch_Amazon-EKS-Distro_16.png
│ │ │ ├── Arch_Amazon-EKS-Distro_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_16.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_16.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_16.png
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_16.svg
│ │ │ ├── Arch_AWS-Fargate_16.png
│ │ │ ├── Arch_AWS-Fargate_16.svg
│ │ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_16.png
│ │ │ └── Arch_Red-Hat-OpenShift-Service-on-AWS_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-ECS-Anywhere_32.png
│ │ │ ├── Arch_Amazon-ECS-Anywhere_32.svg
│ │ │ ├── Arch_Amazon-EKS-Anywhere_32.png
│ │ │ ├── Arch_Amazon-EKS-Anywhere_32.svg
│ │ │ ├── Arch_Amazon-EKS-Cloud_32.png
│ │ │ ├── Arch_Amazon-EKS-Cloud_32.svg
│ │ │ ├── Arch_Amazon-EKS-Distro_32.png
│ │ │ ├── Arch_Amazon-EKS-Distro_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_32.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_32.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_32.png
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_32.svg
│ │ │ ├── Arch_AWS-Fargate_32.png
│ │ │ ├── Arch_AWS-Fargate_32.svg
│ │ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_32.png
│ │ │ └── Arch_Red-Hat-OpenShift-Service-on-AWS_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-ECS-Anywhere_48.png
│ │ │ ├── Arch_Amazon-ECS-Anywhere_48.svg
│ │ │ ├── Arch_Amazon-EKS-Anywhere_48.png
│ │ │ ├── Arch_Amazon-EKS-Anywhere_48.svg
│ │ │ ├── Arch_Amazon-EKS-Cloud_48.png
│ │ │ ├── Arch_Amazon-EKS-Cloud_48.svg
│ │ │ ├── Arch_Amazon-EKS-Distro_48.png
│ │ │ ├── Arch_Amazon-EKS-Distro_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_48.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_48.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_48.png
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_48.svg
│ │ │ ├── Arch_AWS-Fargate_48.png
│ │ │ ├── Arch_AWS-Fargate_48.svg
│ │ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_48.png
│ │ │ └── Arch_Red-Hat-OpenShift-Service-on-AWS_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-ECS-Anywhere_64.png
│ │ ├── Arch_Amazon-ECS-Anywhere_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EKS-Anywhere_64.png
│ │ ├── Arch_Amazon-EKS-Anywhere_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EKS-Cloud_64.png
│ │ ├── Arch_Amazon-EKS-Cloud_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EKS-Distro_64.png
│ │ ├── Arch_Amazon-EKS-Distro_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Container-Registry_64.png
│ │ ├── Arch_Amazon-Elastic-Container-Registry_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Container-Service_64.png
│ │ ├── Arch_Amazon-Elastic-Container-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_64.png
│ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Fargate_64.png
│ │ ├── Arch_AWS-Fargate_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_64.png
│ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_64.svg
│ │ └── [email protected]
│ ├── customer-enablement
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_AWS-Activate_16.png
│ │ │ ├── Arch_AWS-Activate_16.svg
│ │ │ ├── Arch_AWS-IQ_16.png
│ │ │ ├── Arch_AWS-IQ_16.svg
│ │ │ ├── Arch_AWS-Managed-Services_16.png
│ │ │ ├── Arch_AWS-Managed-Services_16.svg
│ │ │ ├── Arch_AWS-Professional-Services_16.png
│ │ │ ├── Arch_AWS-Professional-Services_16.svg
│ │ │ ├── Arch_AWS-rePost_16.png
│ │ │ ├── Arch_AWS-rePost_16.svg
│ │ │ ├── Arch_AWS-rePost-Private_16.png
│ │ │ ├── Arch_AWS-rePost-Private_16.svg
│ │ │ ├── Arch_AWS-Support_16.png
│ │ │ ├── Arch_AWS-Support_16.svg
│ │ │ ├── Arch_AWS-Training-Certification_16.png
│ │ │ └── Arch_AWS-Training-Certification_16.svg
│ │ ├── 32
│ │ │ ├── Arch_AWS-Activate_32.png
│ │ │ ├── Arch_AWS-Activate_32.svg
│ │ │ ├── Arch_AWS-IQ_32.png
│ │ │ ├── Arch_AWS-IQ_32.svg
│ │ │ ├── Arch_AWS-Managed-Services_32.png
│ │ │ ├── Arch_AWS-Managed-Services_32.svg
│ │ │ ├── Arch_AWS-Professional-Services_32.png
│ │ │ ├── Arch_AWS-Professional-Services_32.svg
│ │ │ ├── Arch_AWS-rePost_32.png
│ │ │ ├── Arch_AWS-rePost_32.svg
│ │ │ ├── Arch_AWS-rePost-Private_32.png
│ │ │ ├── Arch_AWS-rePost-Private_32.svg
│ │ │ ├── Arch_AWS-Support_32.png
│ │ │ ├── Arch_AWS-Support_32.svg
│ │ │ ├── Arch_AWS-Training-Certification_32.png
│ │ │ └── Arch_AWS-Training-Certification_32.svg
│ │ ├── 48
│ │ │ ├── Arch_AWS-Activate_48.png
│ │ │ ├── Arch_AWS-Activate_48.svg
│ │ │ ├── Arch_AWS-IQ_48.png
│ │ │ ├── Arch_AWS-IQ_48.svg
│ │ │ ├── Arch_AWS-Managed-Services_48.png
│ │ │ ├── Arch_AWS-Managed-Services_48.svg
│ │ │ ├── Arch_AWS-Professional-Services_48.png
│ │ │ ├── Arch_AWS-Professional-Services_48.svg
│ │ │ ├── Arch_AWS-rePost_48.png
│ │ │ ├── Arch_AWS-rePost_48.svg
│ │ │ ├── Arch_AWS-rePost-Private_48.png
│ │ │ ├── Arch_AWS-rePost-Private_48.svg
│ │ │ ├── Arch_AWS-Support_48.png
│ │ │ ├── Arch_AWS-Support_48.svg
│ │ │ ├── Arch_AWS-Training-Certification_48.png
│ │ │ └── Arch_AWS-Training-Certification_48.svg
│ │ └── 64
│ │ ├── Arch_AWS-Activate_64.png
│ │ ├── Arch_AWS-Activate_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IQ_64.png
│ │ ├── Arch_AWS-IQ_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Managed-Services_64.png
│ │ ├── Arch_AWS-Managed-Services_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Professional-Services_64.png
│ │ ├── Arch_AWS-Professional-Services_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-rePost_64.png
│ │ ├── Arch_AWS-rePost_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-rePost-Private_64.png
│ │ ├── Arch_AWS-rePost-Private_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Support_64.png
│ │ ├── Arch_AWS-Support_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Training-Certification_64.png
│ │ ├── Arch_AWS-Training-Certification_64.svg
│ │ └── [email protected]
│ ├── database
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Aurora_16.png
│ │ │ ├── Arch_Amazon-Aurora_16.svg
│ │ │ ├── Arch_Amazon-DocumentDB_16.png
│ │ │ ├── Arch_Amazon-DocumentDB_16.svg
│ │ │ ├── Arch_Amazon-DynamoDB_16.png
│ │ │ ├── Arch_Amazon-DynamoDB_16.svg
│ │ │ ├── Arch_Amazon-ElastiCache_16.png
│ │ │ ├── Arch_Amazon-ElastiCache_16.svg
│ │ │ ├── Arch_Amazon-Keyspaces_16.png
│ │ │ ├── Arch_Amazon-Keyspaces_16.svg
│ │ │ ├── Arch_Amazon-MemoryDB_16.png
│ │ │ ├── Arch_Amazon-MemoryDB_16.svg
│ │ │ ├── Arch_Amazon-Neptune_16.png
│ │ │ ├── Arch_Amazon-Neptune_16.svg
│ │ │ ├── Arch_Amazon-RDS_16.png
│ │ │ ├── Arch_Amazon-RDS_16.svg
│ │ │ ├── Arch_Amazon-Timestream_16.png
│ │ │ ├── Arch_Amazon-Timestream_16.svg
│ │ │ ├── Arch_AWS-Database-Migration-Service_16.png
│ │ │ ├── Arch_AWS-Database-Migration-Service_16.svg
│ │ │ ├── Arch_Oracle-Database-at-AWS_16.png
│ │ │ └── Arch_Oracle-Database-at-AWS_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Aurora_32.png
│ │ │ ├── Arch_Amazon-Aurora_32.svg
│ │ │ ├── Arch_Amazon-DocumentDB_32.png
│ │ │ ├── Arch_Amazon-DocumentDB_32.svg
│ │ │ ├── Arch_Amazon-DynamoDB_32.png
│ │ │ ├── Arch_Amazon-DynamoDB_32.svg
│ │ │ ├── Arch_Amazon-ElastiCache_32.png
│ │ │ ├── Arch_Amazon-ElastiCache_32.svg
│ │ │ ├── Arch_Amazon-Keyspaces_32.png
│ │ │ ├── Arch_Amazon-Keyspaces_32.svg
│ │ │ ├── Arch_Amazon-MemoryDB_32.png
│ │ │ ├── Arch_Amazon-MemoryDB_32.svg
│ │ │ ├── Arch_Amazon-Neptune_32.png
│ │ │ ├── Arch_Amazon-Neptune_32.svg
│ │ │ ├── Arch_Amazon-RDS_32.png
│ │ │ ├── Arch_Amazon-RDS_32.svg
│ │ │ ├── Arch_Amazon-Timestream_32.png
│ │ │ ├── Arch_Amazon-Timestream_32.svg
│ │ │ ├── Arch_AWS-Database-Migration-Service_32.png
│ │ │ ├── Arch_AWS-Database-Migration-Service_32.svg
│ │ │ ├── Arch_Oracle-Database-at-AWS_32.png
│ │ │ └── Arch_Oracle-Database-at-AWS_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Aurora_48.png
│ │ │ ├── Arch_Amazon-Aurora_48.svg
│ │ │ ├── Arch_Amazon-DocumentDB_48.png
│ │ │ ├── Arch_Amazon-DocumentDB_48.svg
│ │ │ ├── Arch_Amazon-DynamoDB_48.png
│ │ │ ├── Arch_Amazon-DynamoDB_48.svg
│ │ │ ├── Arch_Amazon-ElastiCache_48.png
│ │ │ ├── Arch_Amazon-ElastiCache_48.svg
│ │ │ ├── Arch_Amazon-Keyspaces_48.png
│ │ │ ├── Arch_Amazon-Keyspaces_48.svg
│ │ │ ├── Arch_Amazon-MemoryDB_48.png
│ │ │ ├── Arch_Amazon-MemoryDB_48.svg
│ │ │ ├── Arch_Amazon-Neptune_48.png
│ │ │ ├── Arch_Amazon-Neptune_48.svg
│ │ │ ├── Arch_Amazon-RDS_48.png
│ │ │ ├── Arch_Amazon-RDS_48.svg
│ │ │ ├── Arch_Amazon-Timestream_48.png
│ │ │ ├── Arch_Amazon-Timestream_48.svg
│ │ │ ├── Arch_AWS-Database-Migration-Service_48.png
│ │ │ ├── Arch_AWS-Database-Migration-Service_48.svg
│ │ │ ├── Arch_Oracle-Database-at-AWS_48.png
│ │ │ └── Arch_Oracle-Database-at-AWS_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Aurora_64.png
│ │ ├── Arch_Amazon-Aurora_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DocumentDB_64.png
│ │ ├── Arch_Amazon-DocumentDB_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DynamoDB_64.png
│ │ ├── Arch_Amazon-DynamoDB_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-ElastiCache_64.png
│ │ ├── Arch_Amazon-ElastiCache_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Keyspaces_64.png
│ │ ├── Arch_Amazon-Keyspaces_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-MemoryDB_64.png
│ │ ├── Arch_Amazon-MemoryDB_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Neptune_64.png
│ │ ├── Arch_Amazon-Neptune_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-RDS_64.png
│ │ ├── Arch_Amazon-RDS_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Timestream_64.png
│ │ ├── Arch_Amazon-Timestream_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Database-Migration-Service_64.png
│ │ ├── Arch_AWS-Database-Migration-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Oracle-Database-at-AWS_64.png
│ │ ├── Arch_Oracle-Database-at-AWS_64.svg
│ │ └── [email protected]
│ ├── developer-tools
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CodeCatalyst_16.png
│ │ │ ├── Arch_Amazon-CodeCatalyst_16.svg
│ │ │ ├── Arch_Amazon-Corretto_16.png
│ │ │ ├── Arch_Amazon-Corretto_16.svg
│ │ │ ├── Arch_AWS-Cloud-Control-API_16.png
│ │ │ ├── Arch_AWS-Cloud-Control-API_16.svg
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_16.png
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_16.svg
│ │ │ ├── Arch_AWS-Cloud9_16.png
│ │ │ ├── Arch_AWS-Cloud9_16.svg
│ │ │ ├── Arch_AWS-CloudShell_16.png
│ │ │ ├── Arch_AWS-CloudShell_16.svg
│ │ │ ├── Arch_AWS-CodeArtifact_16.png
│ │ │ ├── Arch_AWS-CodeArtifact_16.svg
│ │ │ ├── Arch_AWS-CodeBuild_16.png
│ │ │ ├── Arch_AWS-CodeBuild_16.svg
│ │ │ ├── Arch_AWS-CodeCommit_16.png
│ │ │ ├── Arch_AWS-CodeCommit_16.svg
│ │ │ ├── Arch_AWS-CodeDeploy_16.png
│ │ │ ├── Arch_AWS-CodeDeploy_16.svg
│ │ │ ├── Arch_AWS-CodePipeline_16.png
│ │ │ ├── Arch_AWS-CodePipeline_16.svg
│ │ │ ├── Arch_AWS-Command-Line-Interface_16.png
│ │ │ ├── Arch_AWS-Command-Line-Interface_16.svg
│ │ │ ├── Arch_AWS-Fault-Injection-Service_16.png
│ │ │ ├── Arch_AWS-Fault-Injection-Service_16.svg
│ │ │ ├── Arch_AWS-Infrastructure-Composer_16.png
│ │ │ ├── Arch_AWS-Infrastructure-Composer_16.svg
│ │ │ ├── Arch_AWS-Tools-and-SDKs_16.png
│ │ │ ├── Arch_AWS-Tools-and-SDKs_16.svg
│ │ │ ├── Arch_AWS-X-Ray_16.png
│ │ │ └── Arch_AWS-X-Ray_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CodeCatalyst_32.png
│ │ │ ├── Arch_Amazon-CodeCatalyst_32.svg
│ │ │ ├── Arch_Amazon-Corretto_32.png
│ │ │ ├── Arch_Amazon-Corretto_32.svg
│ │ │ ├── Arch_AWS-Cloud-Control-API_32.png
│ │ │ ├── Arch_AWS-Cloud-Control-API_32.svg
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_32.png
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_32.svg
│ │ │ ├── Arch_AWS-Cloud9_32.png
│ │ │ ├── Arch_AWS-Cloud9_32.svg
│ │ │ ├── Arch_AWS-CloudShell_32.png
│ │ │ ├── Arch_AWS-CloudShell_32.svg
│ │ │ ├── Arch_AWS-CodeArtifact_32.png
│ │ │ ├── Arch_AWS-CodeArtifact_32.svg
│ │ │ ├── Arch_AWS-CodeBuild_32.png
│ │ │ ├── Arch_AWS-CodeBuild_32.svg
│ │ │ ├── Arch_AWS-CodeCommit_32.png
│ │ │ ├── Arch_AWS-CodeCommit_32.svg
│ │ │ ├── Arch_AWS-CodeDeploy_32.png
│ │ │ ├── Arch_AWS-CodeDeploy_32.svg
│ │ │ ├── Arch_AWS-CodePipeline_32.png
│ │ │ ├── Arch_AWS-CodePipeline_32.svg
│ │ │ ├── Arch_AWS-Command-Line-Interface_32.png
│ │ │ ├── Arch_AWS-Command-Line-Interface_32.svg
│ │ │ ├── Arch_AWS-Fault-Injection-Service_32.png
│ │ │ ├── Arch_AWS-Fault-Injection-Service_32.svg
│ │ │ ├── Arch_AWS-Infrastructure-Composer_32.png
│ │ │ ├── Arch_AWS-Infrastructure-Composer_32.svg
│ │ │ ├── Arch_AWS-Tools-and-SDKs_32.png
│ │ │ ├── Arch_AWS-Tools-and-SDKs_32.svg
│ │ │ ├── Arch_AWS-X-Ray_32.png
│ │ │ └── Arch_AWS-X-Ray_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CodeCatalyst_48.png
│ │ │ ├── Arch_Amazon-CodeCatalyst_48.svg
│ │ │ ├── Arch_Amazon-Corretto_48.png
│ │ │ ├── Arch_Amazon-Corretto_48.svg
│ │ │ ├── Arch_AWS-Cloud-Control-API_48.png
│ │ │ ├── Arch_AWS-Cloud-Control-API_48.svg
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_48.png
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_48.svg
│ │ │ ├── Arch_AWS-Cloud9_48.png
│ │ │ ├── Arch_AWS-Cloud9_48.svg
│ │ │ ├── Arch_AWS-CloudShell_48.png
│ │ │ ├── Arch_AWS-CloudShell_48.svg
│ │ │ ├── Arch_AWS-CodeArtifact_48.png
│ │ │ ├── Arch_AWS-CodeArtifact_48.svg
│ │ │ ├── Arch_AWS-CodeBuild_48.png
│ │ │ ├── Arch_AWS-CodeBuild_48.svg
│ │ │ ├── Arch_AWS-CodeCommit_48.png
│ │ │ ├── Arch_AWS-CodeCommit_48.svg
│ │ │ ├── Arch_AWS-CodeDeploy_48.png
│ │ │ ├── Arch_AWS-CodeDeploy_48.svg
│ │ │ ├── Arch_AWS-CodePipeline_48.png
│ │ │ ├── Arch_AWS-CodePipeline_48.svg
│ │ │ ├── Arch_AWS-Command-Line-Interface_48.png
│ │ │ ├── Arch_AWS-Command-Line-Interface_48.svg
│ │ │ ├── Arch_AWS-Fault-Injection-Service_48.png
│ │ │ ├── Arch_AWS-Fault-Injection-Service_48.svg
│ │ │ ├── Arch_AWS-Infrastructure-Composer_48.png
│ │ │ ├── Arch_AWS-Infrastructure-Composer_48.svg
│ │ │ ├── Arch_AWS-Tools-and-SDKs_48.png
│ │ │ ├── Arch_AWS-Tools-and-SDKs_48.svg
│ │ │ ├── Arch_AWS-X-Ray_48.png
│ │ │ └── Arch_AWS-X-Ray_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-CodeCatalyst_64.png
│ │ ├── Arch_Amazon-CodeCatalyst_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Corretto_64.png
│ │ ├── Arch_Amazon-Corretto_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-Control-API_64.png
│ │ ├── Arch_AWS-Cloud-Control-API_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-Development-Kit_64.png
│ │ ├── Arch_AWS-Cloud-Development-Kit_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud9_64.png
│ │ ├── Arch_AWS-Cloud9_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudShell_64.png
│ │ ├── Arch_AWS-CloudShell_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeArtifact_64.png
│ │ ├── Arch_AWS-CodeArtifact_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeBuild_64.png
│ │ ├── Arch_AWS-CodeBuild_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeCommit_64.png
│ │ ├── Arch_AWS-CodeCommit_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeDeploy_64.png
│ │ ├── Arch_AWS-CodeDeploy_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodePipeline_64.png
│ │ ├── Arch_AWS-CodePipeline_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Command-Line-Interface_64.png
│ │ ├── Arch_AWS-Command-Line-Interface_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Fault-Injection-Service_64.png
│ │ ├── Arch_AWS-Fault-Injection-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Infrastructure-Composer_64.png
│ │ ├── Arch_AWS-Infrastructure-Composer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Tools-and-SDKs_64.png
│ │ ├── Arch_AWS-Tools-and-SDKs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-X-Ray_64.png
│ │ ├── Arch_AWS-X-Ray_64.svg
│ │ └── [email protected]
│ ├── end-user-computing
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppStream-2_16.png
│ │ │ ├── Arch_Amazon-AppStream-2_16.svg
│ │ │ ├── Arch_Amazon-WorkSpaces-Family_16.png
│ │ │ └── Arch_Amazon-WorkSpaces-Family_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppStream-2_32.png
│ │ │ ├── Arch_Amazon-AppStream-2_32.svg
│ │ │ ├── Arch_Amazon-WorkSpaces-Family_32.png
│ │ │ └── Arch_Amazon-WorkSpaces-Family_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppStream-2_48.png
│ │ │ ├── Arch_Amazon-AppStream-2_48.svg
│ │ │ ├── Arch_Amazon-WorkSpaces-Family_48.png
│ │ │ └── Arch_Amazon-WorkSpaces-Family_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-AppStream-2_64.png
│ │ ├── Arch_Amazon-AppStream-2_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkSpaces-Family_64.png
│ │ ├── Arch_Amazon-WorkSpaces-Family_64.svg
│ │ └── [email protected]
│ ├── front-end-web-mobile
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Location-Service_16.png
│ │ │ ├── Arch_Amazon-Location-Service_16.svg
│ │ │ ├── Arch_AWS-Amplify_16.png
│ │ │ ├── Arch_AWS-Amplify_16.svg
│ │ │ ├── Arch_AWS-Device-Farm_16.png
│ │ │ └── Arch_AWS-Device-Farm_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Location-Service_32.png
│ │ │ ├── Arch_Amazon-Location-Service_32.svg
│ │ │ ├── Arch_AWS-Amplify_32.png
│ │ │ ├── Arch_AWS-Amplify_32.svg
│ │ │ ├── Arch_AWS-Device-Farm_32.png
│ │ │ └── Arch_AWS-Device-Farm_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Location-Service_48.png
│ │ │ ├── Arch_Amazon-Location-Service_48.svg
│ │ │ ├── Arch_AWS-Amplify_48.png
│ │ │ ├── Arch_AWS-Amplify_48.svg
│ │ │ ├── Arch_AWS-Device-Farm_48.png
│ │ │ └── Arch_AWS-Device-Farm_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Location-Service_64.png
│ │ ├── Arch_Amazon-Location-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Amplify_64.png
│ │ ├── Arch_AWS-Amplify_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Device-Farm_64.png
│ │ ├── Arch_AWS-Device-Farm_64.svg
│ │ └── [email protected]
│ ├── games
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-GameLift-Servers_16.png
│ │ │ ├── Arch_Amazon-GameLift-Servers_16.svg
│ │ │ ├── Arch_Amazon-GameLift-Streams_16.png
│ │ │ ├── Arch_Amazon-GameLift-Streams_16.svg
│ │ │ ├── Arch_Open-3D-Engine_16.png
│ │ │ └── Arch_Open-3D-Engine_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-GameLift-Servers_32.png
│ │ │ ├── Arch_Amazon-GameLift-Servers_32.svg
│ │ │ ├── Arch_Amazon-GameLift-Streams_32.png
│ │ │ ├── Arch_Amazon-GameLift-Streams_32.svg
│ │ │ ├── Arch_Open-3D-Engine_32.png
│ │ │ └── Arch_Open-3D-Engine_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-GameLift-Servers_48.png
│ │ │ ├── Arch_Amazon-GameLift-Servers_48.svg
│ │ │ ├── Arch_Amazon-GameLift-Streams_48.png
│ │ │ ├── Arch_Amazon-GameLift-Streams_48.svg
│ │ │ ├── Arch_Open-3D-Engine_48.png
│ │ │ └── Arch_Open-3D-Engine_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-GameLift-Servers_64.png
│ │ ├── Arch_Amazon-GameLift-Servers_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-GameLift-Streams_64.png
│ │ ├── Arch_Amazon-GameLift-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Open-3D-Engine_64.png
│ │ ├── Arch_Open-3D-Engine_64.svg
│ │ └── [email protected]
│ ├── general-icons
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_AWS-Marketplace_Dark_16.png
│ │ │ ├── Arch_AWS-Marketplace_Dark_16.svg
│ │ │ ├── Arch_AWS-Marketplace_Light_16.png
│ │ │ └── Arch_AWS-Marketplace_Light_16.svg
│ │ ├── 32
│ │ │ ├── Arch_AWS-Marketplace_Dark_32.png
│ │ │ ├── Arch_AWS-Marketplace_Dark_32.svg
│ │ │ ├── Arch_AWS-Marketplace_Light_32.png
│ │ │ └── Arch_AWS-Marketplace_Light_32.svg
│ │ ├── 48
│ │ │ ├── Arch_AWS-Marketplace_Dark_48.png
│ │ │ ├── Arch_AWS-Marketplace_Dark_48.svg
│ │ │ ├── Arch_AWS-Marketplace_Light_48.png
│ │ │ └── Arch_AWS-Marketplace_Light_48.svg
│ │ └── 64
│ │ ├── Arch_AWS-Marketplace_Dark_64.png
│ │ ├── Arch_AWS-Marketplace_Dark_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Marketplace_Light_64.png
│ │ ├── Arch_AWS-Marketplace_Light_64.svg
│ │ └── [email protected]
│ ├── internet-of-things
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-IoT-Analytics_16.png
│ │ │ ├── Arch_AWS-IoT-Analytics_16.svg
│ │ │ ├── Arch_AWS-IoT-Button_16.png
│ │ │ ├── Arch_AWS-IoT-Button_16.svg
│ │ │ ├── Arch_AWS-IoT-Core_16.png
│ │ │ ├── Arch_AWS-IoT-Core_16.svg
│ │ │ ├── Arch_AWS-IoT-Device-Defender_16.png
│ │ │ ├── Arch_AWS-IoT-Device-Defender_16.svg
│ │ │ ├── Arch_AWS-IoT-Device-Management_16.png
│ │ │ ├── Arch_AWS-IoT-Device-Management_16.svg
│ │ │ ├── Arch_AWS-IoT-Events_16.png
│ │ │ ├── Arch_AWS-IoT-Events_16.svg
│ │ │ ├── Arch_AWS-IoT-ExpressLink_16.png
│ │ │ ├── Arch_AWS-IoT-ExpressLink_16.svg
│ │ │ ├── Arch_AWS-IoT-FleetWise_16.png
│ │ │ ├── Arch_AWS-IoT-FleetWise_16.svg
│ │ │ ├── Arch_AWS-IoT-Greengrass_16.png
│ │ │ ├── Arch_AWS-IoT-Greengrass_16.svg
│ │ │ ├── Arch_AWS-IoT-SiteWise_16.png
│ │ │ ├── Arch_AWS-IoT-SiteWise_16.svg
│ │ │ ├── Arch_AWS-IoT-TwinMaker_16.png
│ │ │ ├── Arch_AWS-IoT-TwinMaker_16.svg
│ │ │ ├── Arch_FreeRTOS_16.png
│ │ │ └── Arch_FreeRTOS_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-IoT-Analytics_32.png
│ │ │ ├── Arch_AWS-IoT-Analytics_32.svg
│ │ │ ├── Arch_AWS-IoT-Button_32.png
│ │ │ ├── Arch_AWS-IoT-Button_32.svg
│ │ │ ├── Arch_AWS-IoT-Core_32.png
│ │ │ ├── Arch_AWS-IoT-Core_32.svg
│ │ │ ├── Arch_AWS-IoT-Device-Defender_32.png
│ │ │ ├── Arch_AWS-IoT-Device-Defender_32.svg
│ │ │ ├── Arch_AWS-IoT-Device-Management_32.png
│ │ │ ├── Arch_AWS-IoT-Device-Management_32.svg
│ │ │ ├── Arch_AWS-IoT-Events_32.png
│ │ │ ├── Arch_AWS-IoT-Events_32.svg
│ │ │ ├── Arch_AWS-IoT-ExpressLink_32.png
│ │ │ ├── Arch_AWS-IoT-ExpressLink_32.svg
│ │ │ ├── Arch_AWS-IoT-FleetWise_32.png
│ │ │ ├── Arch_AWS-IoT-FleetWise_32.svg
│ │ │ ├── Arch_AWS-IoT-Greengrass_32.png
│ │ │ ├── Arch_AWS-IoT-Greengrass_32.svg
│ │ │ ├── Arch_AWS-IoT-SiteWise_32.png
│ │ │ ├── Arch_AWS-IoT-SiteWise_32.svg
│ │ │ ├── Arch_AWS-IoT-TwinMaker_32.png
│ │ │ ├── Arch_AWS-IoT-TwinMaker_32.svg
│ │ │ ├── Arch_FreeRTOS_32.png
│ │ │ └── Arch_FreeRTOS_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-IoT-Analytics_48.png
│ │ │ ├── Arch_AWS-IoT-Analytics_48.svg
│ │ │ ├── Arch_AWS-IoT-Button_48.png
│ │ │ ├── Arch_AWS-IoT-Button_48.svg
│ │ │ ├── Arch_AWS-IoT-Core_48.png
│ │ │ ├── Arch_AWS-IoT-Core_48.svg
│ │ │ ├── Arch_AWS-IoT-Device-Defender_48.png
│ │ │ ├── Arch_AWS-IoT-Device-Defender_48.svg
│ │ │ ├── Arch_AWS-IoT-Device-Management_48.png
│ │ │ ├── Arch_AWS-IoT-Device-Management_48.svg
│ │ │ ├── Arch_AWS-IoT-Events_48.png
│ │ │ ├── Arch_AWS-IoT-Events_48.svg
│ │ │ ├── Arch_AWS-IoT-ExpressLink_48.png
│ │ │ ├── Arch_AWS-IoT-ExpressLink_48.svg
│ │ │ ├── Arch_AWS-IoT-FleetWise_48.png
│ │ │ ├── Arch_AWS-IoT-FleetWise_48.svg
│ │ │ ├── Arch_AWS-IoT-Greengrass_48.png
│ │ │ ├── Arch_AWS-IoT-Greengrass_48.svg
│ │ │ ├── Arch_AWS-IoT-SiteWise_48.png
│ │ │ ├── Arch_AWS-IoT-SiteWise_48.svg
│ │ │ ├── Arch_AWS-IoT-TwinMaker_48.png
│ │ │ ├── Arch_AWS-IoT-TwinMaker_48.svg
│ │ │ ├── Arch_FreeRTOS_48.png
│ │ │ └── Arch_FreeRTOS_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_AWS-IoT-Analytics_64.png
│ │ ├── Arch_AWS-IoT-Analytics_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Button_64.png
│ │ ├── Arch_AWS-IoT-Button_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Core_64.png
│ │ ├── Arch_AWS-IoT-Core_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Device-Defender_64.png
│ │ ├── Arch_AWS-IoT-Device-Defender_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Device-Management_64.png
│ │ ├── Arch_AWS-IoT-Device-Management_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Events_64.png
│ │ ├── Arch_AWS-IoT-Events_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-ExpressLink_64.png
│ │ ├── Arch_AWS-IoT-ExpressLink_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-FleetWise_64.png
│ │ ├── Arch_AWS-IoT-FleetWise_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Greengrass_64.png
│ │ ├── Arch_AWS-IoT-Greengrass_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-SiteWise_64.png
│ │ ├── Arch_AWS-IoT-SiteWise_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-TwinMaker_64.png
│ │ ├── Arch_AWS-IoT-TwinMaker_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_FreeRTOS_64.png
│ │ ├── Arch_FreeRTOS_64.svg
│ │ └── [email protected]
│ ├── management-governance
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CloudWatch_16.png
│ │ │ ├── Arch_Amazon-CloudWatch_16.svg
│ │ │ ├── Arch_Amazon-Managed-Grafana_16.png
│ │ │ ├── Arch_Amazon-Managed-Grafana_16.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_16.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_16.svg
│ │ │ ├── Arch_AWS-AppConfig_16.png
│ │ │ ├── Arch_AWS-AppConfig_16.svg
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_16.png
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_16.svg
│ │ │ ├── Arch_AWS-Auto-Scaling_16.png
│ │ │ ├── Arch_AWS-Auto-Scaling_16.svg
│ │ │ ├── Arch_AWS-Backint-Agent_16.png
│ │ │ ├── Arch_AWS-Backint-Agent_16.svg
│ │ │ ├── Arch_AWS-Chatbot_16.png
│ │ │ ├── Arch_AWS-Chatbot_16.svg
│ │ │ ├── Arch_AWS-CloudFormation_16.png
│ │ │ ├── Arch_AWS-CloudFormation_16.svg
│ │ │ ├── Arch_AWS-CloudTrail_16.png
│ │ │ ├── Arch_AWS-CloudTrail_16.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.svg
│ │ │ ├── Arch_AWS-Config_16.png
│ │ │ ├── Arch_AWS-Config_16.svg
│ │ │ ├── Arch_AWS-Console-Mobile-Application_16.png
│ │ │ ├── Arch_AWS-Console-Mobile-Application_16.svg
│ │ │ ├── Arch_AWS-Control-Tower_16.png
│ │ │ ├── Arch_AWS-Control-Tower_16.svg
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_16.png
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_16.svg
│ │ │ ├── Arch_AWS-Health-Dashboard_16.png
│ │ │ ├── Arch_AWS-Health-Dashboard_16.svg
│ │ │ ├── Arch_AWS-Launch-Wizard_16.png
│ │ │ ├── Arch_AWS-Launch-Wizard_16.svg
│ │ │ ├── Arch_AWS-License-Manager_16.png
│ │ │ ├── Arch_AWS-License-Manager_16.svg
│ │ │ ├── Arch_AWS-Management-Console_16.png
│ │ │ ├── Arch_AWS-Management-Console_16.svg
│ │ │ ├── Arch_AWS-Organizations_16.png
│ │ │ ├── Arch_AWS-Organizations_16.svg
│ │ │ ├── Arch_AWS-Proton_16.png
│ │ │ ├── Arch_AWS-Proton_16.svg
│ │ │ ├── Arch_AWS-Resilience-Hub_16.png
│ │ │ ├── Arch_AWS-Resilience-Hub_16.svg
│ │ │ ├── Arch_AWS-Resource-Explorer_16.png
│ │ │ ├── Arch_AWS-Resource-Explorer_16.svg
│ │ │ ├── Arch_AWS-Service-Catalog_16.png
│ │ │ ├── Arch_AWS-Service-Catalog_16.svg
│ │ │ ├── Arch_AWS-Service-Management-Connector_16.png
│ │ │ ├── Arch_AWS-Service-Management-Connector_16.svg
│ │ │ ├── Arch_AWS-Systems-Manager_16.png
│ │ │ ├── Arch_AWS-Systems-Manager_16.svg
│ │ │ ├── Arch_AWS-Telco-Network-Builder_16.png
│ │ │ ├── Arch_AWS-Telco-Network-Builder_16.svg
│ │ │ ├── Arch_AWS-Trusted-Advisor_16.png
│ │ │ ├── Arch_AWS-Trusted-Advisor_16.svg
│ │ │ ├── Arch_AWS-User-Notifications_16.png
│ │ │ ├── Arch_AWS-User-Notifications_16.svg
│ │ │ ├── Arch_AWS-Well-Architected-Tool_16.png
│ │ │ └── Arch_AWS-Well-Architected-Tool_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CloudWatch_32.png
│ │ │ ├── Arch_Amazon-CloudWatch_32.svg
│ │ │ ├── Arch_Amazon-Managed-Grafana_32.png
│ │ │ ├── Arch_Amazon-Managed-Grafana_32.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_32.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_32.svg
│ │ │ ├── Arch_AWS-AppConfig_32.png
│ │ │ ├── Arch_AWS-AppConfig_32.svg
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_32.png
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_32.svg
│ │ │ ├── Arch_AWS-Auto-Scaling_32.png
│ │ │ ├── Arch_AWS-Auto-Scaling_32.svg
│ │ │ ├── Arch_AWS-Backint-Agent_32.png
│ │ │ ├── Arch_AWS-Backint-Agent_32.svg
│ │ │ ├── Arch_AWS-Chatbot_32.png
│ │ │ ├── Arch_AWS-Chatbot_32.svg
│ │ │ ├── Arch_AWS-CloudFormation_32.png
│ │ │ ├── Arch_AWS-CloudFormation_32.svg
│ │ │ ├── Arch_AWS-CloudTrail_32.png
│ │ │ ├── Arch_AWS-CloudTrail_32.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.svg
│ │ │ ├── Arch_AWS-Config_32.png
│ │ │ ├── Arch_AWS-Config_32.svg
│ │ │ ├── Arch_AWS-Console-Mobile-Application_32.png
│ │ │ ├── Arch_AWS-Console-Mobile-Application_32.svg
│ │ │ ├── Arch_AWS-Control-Tower_32.png
│ │ │ ├── Arch_AWS-Control-Tower_32.svg
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_32.png
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_32.svg
│ │ │ ├── Arch_AWS-Health-Dashboard_32.png
│ │ │ ├── Arch_AWS-Health-Dashboard_32.svg
│ │ │ ├── Arch_AWS-Launch-Wizard_32.png
│ │ │ ├── Arch_AWS-Launch-Wizard_32.svg
│ │ │ ├── Arch_AWS-License-Manager_32.png
│ │ │ ├── Arch_AWS-License-Manager_32.svg
│ │ │ ├── Arch_AWS-Management-Console_32.png
│ │ │ ├── Arch_AWS-Management-Console_32.svg
│ │ │ ├── Arch_AWS-Organizations_32.png
│ │ │ ├── Arch_AWS-Organizations_32.svg
│ │ │ ├── Arch_AWS-Proton_32.png
│ │ │ ├── Arch_AWS-Proton_32.svg
│ │ │ ├── Arch_AWS-Resilience-Hub_32.png
│ │ │ ├── Arch_AWS-Resilience-Hub_32.svg
│ │ │ ├── Arch_AWS-Resource-Explorer_32.png
│ │ │ ├── Arch_AWS-Resource-Explorer_32.svg
│ │ │ ├── Arch_AWS-Service-Catalog_32.png
│ │ │ ├── Arch_AWS-Service-Catalog_32.svg
│ │ │ ├── Arch_AWS-Service-Management-Connector_32.png
│ │ │ ├── Arch_AWS-Service-Management-Connector_32.svg
│ │ │ ├── Arch_AWS-Systems-Manager_32.png
│ │ │ ├── Arch_AWS-Systems-Manager_32.svg
│ │ │ ├── Arch_AWS-Telco-Network-Builder_32.png
│ │ │ ├── Arch_AWS-Telco-Network-Builder_32.svg
│ │ │ ├── Arch_AWS-Trusted-Advisor_32.png
│ │ │ ├── Arch_AWS-Trusted-Advisor_32.svg
│ │ │ ├── Arch_AWS-User-Notifications_32.png
│ │ │ ├── Arch_AWS-User-Notifications_32.svg
│ │ │ ├── Arch_AWS-Well-Architected-Tool_32.png
│ │ │ └── Arch_AWS-Well-Architected-Tool_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CloudWatch_48.png
│ │ │ ├── Arch_Amazon-CloudWatch_48.svg
│ │ │ ├── Arch_Amazon-Managed-Grafana_48.png
│ │ │ ├── Arch_Amazon-Managed-Grafana_48.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_48.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_48.svg
│ │ │ ├── Arch_AWS-AppConfig_48.png
│ │ │ ├── Arch_AWS-AppConfig_48.svg
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_48.png
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_48.svg
│ │ │ ├── Arch_AWS-Auto-Scaling_48.png
│ │ │ ├── Arch_AWS-Auto-Scaling_48.svg
│ │ │ ├── Arch_AWS-Backint-Agent_48.png
│ │ │ ├── Arch_AWS-Backint-Agent_48.svg
│ │ │ ├── Arch_AWS-Chatbot_48.png
│ │ │ ├── Arch_AWS-Chatbot_48.svg
│ │ │ ├── Arch_AWS-CloudFormation_48.png
│ │ │ ├── Arch_AWS-CloudFormation_48.svg
│ │ │ ├── Arch_AWS-CloudTrail_48.png
│ │ │ ├── Arch_AWS-CloudTrail_48.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.svg
│ │ │ ├── Arch_AWS-Config_48.png
│ │ │ ├── Arch_AWS-Config_48.svg
│ │ │ ├── Arch_AWS-Console-Mobile-Application_48.png
│ │ │ ├── Arch_AWS-Console-Mobile-Application_48.svg
│ │ │ ├── Arch_AWS-Control-Tower_48.png
│ │ │ ├── Arch_AWS-Control-Tower_48.svg
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_48.png
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_48.svg
│ │ │ ├── Arch_AWS-Health-Dashboard_48.png
│ │ │ ├── Arch_AWS-Health-Dashboard_48.svg
│ │ │ ├── Arch_AWS-Launch-Wizard_48.png
│ │ │ ├── Arch_AWS-Launch-Wizard_48.svg
│ │ │ ├── Arch_AWS-License-Manager_48.png
│ │ │ ├── Arch_AWS-License-Manager_48.svg
│ │ │ ├── Arch_AWS-Management-Console_48.png
│ │ │ ├── Arch_AWS-Management-Console_48.svg
│ │ │ ├── Arch_AWS-Organizations_48.png
│ │ │ ├── Arch_AWS-Organizations_48.svg
│ │ │ ├── Arch_AWS-Proton_48.png
│ │ │ ├── Arch_AWS-Proton_48.svg
│ │ │ ├── Arch_AWS-Resilience-Hub_48.png
│ │ │ ├── Arch_AWS-Resilience-Hub_48.svg
│ │ │ ├── Arch_AWS-Resource-Explorer_48.png
│ │ │ ├── Arch_AWS-Resource-Explorer_48.svg
│ │ │ ├── Arch_AWS-Service-Catalog_48.png
│ │ │ ├── Arch_AWS-Service-Catalog_48.svg
│ │ │ ├── Arch_AWS-Service-Management-Connector_48.png
│ │ │ ├── Arch_AWS-Service-Management-Connector_48.svg
│ │ │ ├── Arch_AWS-Systems-Manager_48.png
│ │ │ ├── Arch_AWS-Systems-Manager_48.svg
│ │ │ ├── Arch_AWS-Telco-Network-Builder_48.png
│ │ │ ├── Arch_AWS-Telco-Network-Builder_48.svg
│ │ │ ├── Arch_AWS-Trusted-Advisor_48.png
│ │ │ ├── Arch_AWS-Trusted-Advisor_48.svg
│ │ │ ├── Arch_AWS-User-Notifications_48.png
│ │ │ ├── Arch_AWS-User-Notifications_48.svg
│ │ │ ├── Arch_AWS-Well-Architected-Tool_48.png
│ │ │ └── Arch_AWS-Well-Architected-Tool_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-CloudWatch_64.png
│ │ ├── Arch_Amazon-CloudWatch_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Grafana_64.png
│ │ ├── Arch_Amazon-Managed-Grafana_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_64.png
│ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-AppConfig_64.png
│ │ ├── Arch_AWS-AppConfig_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Application-Auto-Scaling_64.png
│ │ ├── Arch_AWS-Application-Auto-Scaling_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Auto-Scaling_64.png
│ │ ├── Arch_AWS-Auto-Scaling_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Backint-Agent_64.png
│ │ ├── Arch_AWS-Backint-Agent_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Chatbot_64.png
│ │ ├── Arch_AWS-Chatbot_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudFormation_64.png
│ │ ├── Arch_AWS-CloudFormation_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudTrail_64.png
│ │ ├── Arch_AWS-CloudTrail_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Compute-Optimizer_64.png
│ │ ├── Arch_AWS-Compute-Optimizer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Config_64.png
│ │ ├── Arch_AWS-Config_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Console-Mobile-Application_64.png
│ │ ├── Arch_AWS-Console-Mobile-Application_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Control-Tower_64.png
│ │ ├── Arch_AWS-Control-Tower_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Distro-for-OpenTelemetry_64.png
│ │ ├── Arch_AWS-Distro-for-OpenTelemetry_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Health-Dashboard_64.png
│ │ ├── Arch_AWS-Health-Dashboard_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Launch-Wizard_64.png
│ │ ├── Arch_AWS-Launch-Wizard_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-License-Manager_64.png
│ │ ├── Arch_AWS-License-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Management-Console_64.png
│ │ ├── Arch_AWS-Management-Console_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Organizations_64.png
│ │ ├── Arch_AWS-Organizations_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Proton_64.png
│ │ ├── Arch_AWS-Proton_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Resilience-Hub_64.png
│ │ ├── Arch_AWS-Resilience-Hub_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Resource-Explorer_64.png
│ │ ├── Arch_AWS-Resource-Explorer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Service-Catalog_64.png
│ │ ├── Arch_AWS-Service-Catalog_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Service-Management-Connector_64.png
│ │ ├── Arch_AWS-Service-Management-Connector_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Systems-Manager_64.png
│ │ ├── Arch_AWS-Systems-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Telco-Network-Builder_64.png
│ │ ├── Arch_AWS-Telco-Network-Builder_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Trusted-Advisor_64.png
│ │ ├── Arch_AWS-Trusted-Advisor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-User-Notifications_64.png
│ │ ├── Arch_AWS-User-Notifications_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Well-Architected-Tool_64.png
│ │ ├── Arch_AWS-Well-Architected-Tool_64.svg
│ │ └── [email protected]
│ ├── media-services
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_16.png
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_16.svg
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_16.png
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_16.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.svg
│ │ │ ├── Arch_AWS-Deadline-Cloud_16.png
│ │ │ ├── Arch_AWS-Deadline-Cloud_16.svg
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_16.png
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_16.svg
│ │ │ ├── Arch_AWS-Elemental-Conductor_16.png
│ │ │ ├── Arch_AWS-Elemental-Conductor_16.svg
│ │ │ ├── Arch_AWS-Elemental-Delta_16.png
│ │ │ ├── Arch_AWS-Elemental-Delta_16.svg
│ │ │ ├── Arch_AWS-Elemental-Link_16.png
│ │ │ ├── Arch_AWS-Elemental-Link_16.svg
│ │ │ ├── Arch_AWS-Elemental-Live_16.png
│ │ │ ├── Arch_AWS-Elemental-Live_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaLive_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaLive_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaStore_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaStore_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_16.svg
│ │ │ ├── Arch_AWS-Elemental-Server_16.png
│ │ │ ├── Arch_AWS-Elemental-Server_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Frost_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Frost_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-XMesh_16.png
│ │ │ └── Arch_AWS-Thinkbox-XMesh_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_32.png
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_32.svg
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_32.png
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_32.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.svg
│ │ │ ├── Arch_AWS-Deadline-Cloud_32.png
│ │ │ ├── Arch_AWS-Deadline-Cloud_32.svg
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_32.png
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_32.svg
│ │ │ ├── Arch_AWS-Elemental-Conductor_32.png
│ │ │ ├── Arch_AWS-Elemental-Conductor_32.svg
│ │ │ ├── Arch_AWS-Elemental-Delta_32.png
│ │ │ ├── Arch_AWS-Elemental-Delta_32.svg
│ │ │ ├── Arch_AWS-Elemental-Link_32.png
│ │ │ ├── Arch_AWS-Elemental-Link_32.svg
│ │ │ ├── Arch_AWS-Elemental-Live_32.png
│ │ │ ├── Arch_AWS-Elemental-Live_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaLive_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaLive_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaStore_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaStore_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_32.svg
│ │ │ ├── Arch_AWS-Elemental-Server_32.png
│ │ │ ├── Arch_AWS-Elemental-Server_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Frost_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Frost_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-XMesh_32.png
│ │ │ └── Arch_AWS-Thinkbox-XMesh_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_48.png
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_48.svg
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_48.png
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_48.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.svg
│ │ │ ├── Arch_AWS-Deadline-Cloud_48.png
│ │ │ ├── Arch_AWS-Deadline-Cloud_48.svg
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_48.png
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_48.svg
│ │ │ ├── Arch_AWS-Elemental-Conductor_48.png
│ │ │ ├── Arch_AWS-Elemental-Conductor_48.svg
│ │ │ ├── Arch_AWS-Elemental-Delta_48.png
│ │ │ ├── Arch_AWS-Elemental-Delta_48.svg
│ │ │ ├── Arch_AWS-Elemental-Link_48.png
│ │ │ ├── Arch_AWS-Elemental-Link_48.svg
│ │ │ ├── Arch_AWS-Elemental-Live_48.png
│ │ │ ├── Arch_AWS-Elemental-Live_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaLive_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaLive_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaStore_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaStore_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_48.svg
│ │ │ ├── Arch_AWS-Elemental-Server_48.png
│ │ │ ├── Arch_AWS-Elemental-Server_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Frost_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Frost_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-XMesh_48.png
│ │ │ └── Arch_AWS-Thinkbox-XMesh_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Elastic-Transcoder_64.png
│ │ ├── Arch_Amazon-Elastic-Transcoder_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Interactive-Video-Service_64.png
│ │ ├── Arch_Amazon-Interactive-Video-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.png
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Deadline-Cloud_64.png
│ │ ├── Arch_AWS-Deadline-Cloud_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Appliances-&-Software_64.png
│ │ ├── Arch_AWS-Elemental-Appliances-&-Software_64.svg
│ │ ├── Arch_AWS-Elemental-Appliances-&[email protected]
│ │ ├── Arch_AWS-Elemental-Conductor_64.png
│ │ ├── Arch_AWS-Elemental-Conductor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Delta_64.png
│ │ ├── Arch_AWS-Elemental-Delta_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Link_64.png
│ │ ├── Arch_AWS-Elemental-Link_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Live_64.png
│ │ ├── Arch_AWS-Elemental-Live_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaConnect_64.png
│ │ ├── Arch_AWS-Elemental-MediaConnect_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaConvert_64.png
│ │ ├── Arch_AWS-Elemental-MediaConvert_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaLive_64.png
│ │ ├── Arch_AWS-Elemental-MediaLive_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaPackage_64.png
│ │ ├── Arch_AWS-Elemental-MediaPackage_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaStore_64.png
│ │ ├── Arch_AWS-Elemental-MediaStore_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaTailor_64.png
│ │ ├── Arch_AWS-Elemental-MediaTailor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Server_64.png
│ │ ├── Arch_AWS-Elemental-Server_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Deadline_64.png
│ │ ├── Arch_AWS-Thinkbox-Deadline_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Frost_64.png
│ │ ├── Arch_AWS-Thinkbox-Frost_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Krakatoa_64.png
│ │ ├── Arch_AWS-Thinkbox-Krakatoa_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Sequoia_64.png
│ │ ├── Arch_AWS-Thinkbox-Sequoia_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Stoke_64.png
│ │ ├── Arch_AWS-Thinkbox-Stoke_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-XMesh_64.png
│ │ ├── Arch_AWS-Thinkbox-XMesh_64.svg
│ │ └── [email protected]
│ ├── migration-modernization
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Application-Discovery-Service_16.png
│ │ │ ├── Arch_AWS-Application-Discovery-Service_16.svg
│ │ │ ├── Arch_AWS-Application-Migration-Service_16.png
│ │ │ ├── Arch_AWS-Application-Migration-Service_16.svg
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_16.png
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_16.svg
│ │ │ ├── Arch_AWS-DataSync_16.png
│ │ │ ├── Arch_AWS-DataSync_16.svg
│ │ │ ├── Arch_AWS-Mainframe-Modernization_16.png
│ │ │ ├── Arch_AWS-Mainframe-Modernization_16.svg
│ │ │ ├── Arch_AWS-Migration-Evaluator_16.png
│ │ │ ├── Arch_AWS-Migration-Evaluator_16.svg
│ │ │ ├── Arch_AWS-Migration-Hub_16.png
│ │ │ ├── Arch_AWS-Migration-Hub_16.svg
│ │ │ ├── Arch_AWS-Transfer-Family_16.png
│ │ │ ├── Arch_AWS-Transfer-Family_16.svg
│ │ │ ├── Arch_AWS-Transform_16.png
│ │ │ └── Arch_AWS-Transform_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Application-Discovery-Service_32.png
│ │ │ ├── Arch_AWS-Application-Discovery-Service_32.svg
│ │ │ ├── Arch_AWS-Application-Migration-Service_32.png
│ │ │ ├── Arch_AWS-Application-Migration-Service_32.svg
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_32.png
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_32.svg
│ │ │ ├── Arch_AWS-DataSync_32.png
│ │ │ ├── Arch_AWS-DataSync_32.svg
│ │ │ ├── Arch_AWS-Mainframe-Modernization_32.png
│ │ │ ├── Arch_AWS-Mainframe-Modernization_32.svg
│ │ │ ├── Arch_AWS-Migration-Evaluator_32.png
│ │ │ ├── Arch_AWS-Migration-Evaluator_32.svg
│ │ │ ├── Arch_AWS-Migration-Hub_32.png
│ │ │ ├── Arch_AWS-Migration-Hub_32.svg
│ │ │ ├── Arch_AWS-Transfer-Family_32.png
│ │ │ ├── Arch_AWS-Transfer-Family_32.svg
│ │ │ ├── Arch_AWS-Transform_32.png
│ │ │ └── Arch_AWS-Transform_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Application-Discovery-Service_48.png
│ │ │ ├── Arch_AWS-Application-Discovery-Service_48.svg
│ │ │ ├── Arch_AWS-Application-Migration-Service_48.png
│ │ │ ├── Arch_AWS-Application-Migration-Service_48.svg
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_48.png
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_48.svg
│ │ │ ├── Arch_AWS-DataSync_48.png
│ │ │ ├── Arch_AWS-DataSync_48.svg
│ │ │ ├── Arch_AWS-Mainframe-Modernization_48.png
│ │ │ ├── Arch_AWS-Mainframe-Modernization_48.svg
│ │ │ ├── Arch_AWS-Migration-Evaluator_48.png
│ │ │ ├── Arch_AWS-Migration-Evaluator_48.svg
│ │ │ ├── Arch_AWS-Migration-Hub_48.png
│ │ │ ├── Arch_AWS-Migration-Hub_48.svg
│ │ │ ├── Arch_AWS-Transfer-Family_48.png
│ │ │ ├── Arch_AWS-Transfer-Family_48.svg
│ │ │ ├── Arch_AWS-Transform_48.png
│ │ │ └── Arch_AWS-Transform_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_AWS-Application-Discovery-Service_64.png
│ │ ├── Arch_AWS-Application-Discovery-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Application-Migration-Service_64.png
│ │ ├── Arch_AWS-Application-Migration-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Data-Transfer-Terminal_64.png
│ │ ├── Arch_AWS-Data-Transfer-Terminal_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-DataSync_64.png
│ │ ├── Arch_AWS-DataSync_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Mainframe-Modernization_64.png
│ │ ├── Arch_AWS-Mainframe-Modernization_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Migration-Evaluator_64.png
│ │ ├── Arch_AWS-Migration-Evaluator_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Migration-Hub_64.png
│ │ ├── Arch_AWS-Migration-Hub_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Transfer-Family_64.png
│ │ ├── Arch_AWS-Transfer-Family_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Transform_64.png
│ │ ├── Arch_AWS-Transform_64.svg
│ │ └── [email protected]
│ ├── networking-content-delivery
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-API-Gateway_16.png
│ │ │ ├── Arch_Amazon-API-Gateway_16.svg
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_16.png
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_16.svg
│ │ │ ├── Arch_Amazon-CloudFront_16.png
│ │ │ ├── Arch_Amazon-CloudFront_16.svg
│ │ │ ├── Arch_Amazon-Route-53_16.png
│ │ │ ├── Arch_Amazon-Route-53_16.svg
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_16.png
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_16.svg
│ │ │ ├── Arch_Amazon-VPC-Lattice_16.png
│ │ │ ├── Arch_Amazon-VPC-Lattice_16.svg
│ │ │ ├── Arch_AWS-App-Mesh_16.png
│ │ │ ├── Arch_AWS-App-Mesh_16.svg
│ │ │ ├── Arch_AWS-Client-VPN_16.png
│ │ │ ├── Arch_AWS-Client-VPN_16.svg
│ │ │ ├── Arch_AWS-Cloud-Map_16.png
│ │ │ ├── Arch_AWS-Cloud-Map_16.svg
│ │ │ ├── Arch_AWS-Cloud-WAN_16.png
│ │ │ ├── Arch_AWS-Cloud-WAN_16.svg
│ │ │ ├── Arch_AWS-Direct-Connect_16.png
│ │ │ ├── Arch_AWS-Direct-Connect_16.svg
│ │ │ ├── Arch_AWS-Global-Accelerator_16.png
│ │ │ ├── Arch_AWS-Global-Accelerator_16.svg
│ │ │ ├── Arch_AWS-Private-5G_16.png
│ │ │ ├── Arch_AWS-Private-5G_16.svg
│ │ │ ├── Arch_AWS-PrivateLink_16.png
│ │ │ ├── Arch_AWS-PrivateLink_16.svg
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_16.png
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_16.svg
│ │ │ ├── Arch_AWS-Transit-Gateway_16.png
│ │ │ ├── Arch_AWS-Transit-Gateway_16.svg
│ │ │ ├── Arch_AWS-Verified-Access_16.png
│ │ │ ├── Arch_AWS-Verified-Access_16.svg
│ │ │ ├── Arch_Elastic-Load-Balancing_16.png
│ │ │ └── Arch_Elastic-Load-Balancing_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-API-Gateway_32.png
│ │ │ ├── Arch_Amazon-API-Gateway_32.svg
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_32.png
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_32.svg
│ │ │ ├── Arch_Amazon-CloudFront_32.png
│ │ │ ├── Arch_Amazon-CloudFront_32.svg
│ │ │ ├── Arch_Amazon-Route-53_32.png
│ │ │ ├── Arch_Amazon-Route-53_32.svg
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_32.png
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_32.svg
│ │ │ ├── Arch_Amazon-VPC-Lattice_32.png
│ │ │ ├── Arch_Amazon-VPC-Lattice_32.svg
│ │ │ ├── Arch_AWS-App-Mesh_32.png
│ │ │ ├── Arch_AWS-App-Mesh_32.svg
│ │ │ ├── Arch_AWS-Client-VPN_32.png
│ │ │ ├── Arch_AWS-Client-VPN_32.svg
│ │ │ ├── Arch_AWS-Cloud-Map_32.png
│ │ │ ├── Arch_AWS-Cloud-Map_32.svg
│ │ │ ├── Arch_AWS-Cloud-WAN_32.png
│ │ │ ├── Arch_AWS-Cloud-WAN_32.svg
│ │ │ ├── Arch_AWS-Direct-Connect_32.png
│ │ │ ├── Arch_AWS-Direct-Connect_32.svg
│ │ │ ├── Arch_AWS-Global-Accelerator_32.png
│ │ │ ├── Arch_AWS-Global-Accelerator_32.svg
│ │ │ ├── Arch_AWS-Private-5G_32.png
│ │ │ ├── Arch_AWS-Private-5G_32.svg
│ │ │ ├── Arch_AWS-PrivateLink_32.png
│ │ │ ├── Arch_AWS-PrivateLink_32.svg
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_32.png
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_32.svg
│ │ │ ├── Arch_AWS-Transit-Gateway_32.png
│ │ │ ├── Arch_AWS-Transit-Gateway_32.svg
│ │ │ ├── Arch_AWS-Verified-Access_32.png
│ │ │ ├── Arch_AWS-Verified-Access_32.svg
│ │ │ ├── Arch_Elastic-Load-Balancing_32.png
│ │ │ └── Arch_Elastic-Load-Balancing_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-API-Gateway_48.png
│ │ │ ├── Arch_Amazon-API-Gateway_48.svg
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_48.png
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_48.svg
│ │ │ ├── Arch_Amazon-CloudFront_48.png
│ │ │ ├── Arch_Amazon-CloudFront_48.svg
│ │ │ ├── Arch_Amazon-Route-53_48.png
│ │ │ ├── Arch_Amazon-Route-53_48.svg
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_48.png
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_48.svg
│ │ │ ├── Arch_Amazon-VPC-Lattice_48.png
│ │ │ ├── Arch_Amazon-VPC-Lattice_48.svg
│ │ │ ├── Arch_AWS-App-Mesh_48.png
│ │ │ ├── Arch_AWS-App-Mesh_48.svg
│ │ │ ├── Arch_AWS-Client-VPN_48.png
│ │ │ ├── Arch_AWS-Client-VPN_48.svg
│ │ │ ├── Arch_AWS-Cloud-Map_48.png
│ │ │ ├── Arch_AWS-Cloud-Map_48.svg
│ │ │ ├── Arch_AWS-Cloud-WAN_48.png
│ │ │ ├── Arch_AWS-Cloud-WAN_48.svg
│ │ │ ├── Arch_AWS-Direct-Connect_48.png
│ │ │ ├── Arch_AWS-Direct-Connect_48.svg
│ │ │ ├── Arch_AWS-Global-Accelerator_48.png
│ │ │ ├── Arch_AWS-Global-Accelerator_48.svg
│ │ │ ├── Arch_AWS-Private-5G_48.png
│ │ │ ├── Arch_AWS-Private-5G_48.svg
│ │ │ ├── Arch_AWS-PrivateLink_48.png
│ │ │ ├── Arch_AWS-PrivateLink_48.svg
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_48.png
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_48.svg
│ │ │ ├── Arch_AWS-Transit-Gateway_48.png
│ │ │ ├── Arch_AWS-Transit-Gateway_48.svg
│ │ │ ├── Arch_AWS-Verified-Access_48.png
│ │ │ ├── Arch_AWS-Verified-Access_48.svg
│ │ │ ├── Arch_Elastic-Load-Balancing_48.png
│ │ │ └── Arch_Elastic-Load-Balancing_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-API-Gateway_64.png
│ │ ├── Arch_Amazon-API-Gateway_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Application-Recovery-Controller_64.png
│ │ ├── Arch_Amazon-Application-Recovery-Controller_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CloudFront_64.png
│ │ ├── Arch_Amazon-CloudFront_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Route-53_64.png
│ │ ├── Arch_Amazon-Route-53_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Virtual-Private-Cloud_64.png
│ │ ├── Arch_Amazon-Virtual-Private-Cloud_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-VPC-Lattice_64.png
│ │ ├── Arch_Amazon-VPC-Lattice_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-App-Mesh_64.png
│ │ ├── Arch_AWS-App-Mesh_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Client-VPN_64.png
│ │ ├── Arch_AWS-Client-VPN_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-Map_64.png
│ │ ├── Arch_AWS-Cloud-Map_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-WAN_64.png
│ │ ├── Arch_AWS-Cloud-WAN_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Direct-Connect_64.png
│ │ ├── Arch_AWS-Direct-Connect_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Global-Accelerator_64.png
│ │ ├── Arch_AWS-Global-Accelerator_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Private-5G_64.png
│ │ ├── Arch_AWS-Private-5G_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-PrivateLink_64.png
│ │ ├── Arch_AWS-PrivateLink_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Site-to-Site-VPN_64.png
│ │ ├── Arch_AWS-Site-to-Site-VPN_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Transit-Gateway_64.png
│ │ ├── Arch_AWS-Transit-Gateway_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Verified-Access_64.png
│ │ ├── Arch_AWS-Verified-Access_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Elastic-Load-Balancing_64.png
│ │ ├── Arch_Elastic-Load-Balancing_64.svg
│ │ └── [email protected]
│ ├── quantum-technologies
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Braket_16.png
│ │ │ └── Arch_Amazon-Braket_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Braket_32.png
│ │ │ └── Arch_Amazon-Braket_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Braket_48.png
│ │ │ └── Arch_Amazon-Braket_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Braket_64.png
│ │ ├── Arch_Amazon-Braket_64.svg
│ │ └── [email protected]
│ ├── satellite
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_AWS-Ground-Station_16.png
│ │ │ └── Arch_AWS-Ground-Station_16.svg
│ │ ├── 32
│ │ │ ├── Arch_AWS-Ground-Station_32.png
│ │ │ └── Arch_AWS-Ground-Station_32.svg
│ │ ├── 48
│ │ │ ├── Arch_AWS-Ground-Station_48.png
│ │ │ └── Arch_AWS-Ground-Station_48.svg
│ │ └── 64
│ │ ├── Arch_AWS-Ground-Station_64.png
│ │ ├── Arch_AWS-Ground-Station_64.svg
│ │ └── [email protected]
│ ├── security-identity-compliance
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Cloud-Directory_16.png
│ │ │ ├── Arch_Amazon-Cloud-Directory_16.svg
│ │ │ ├── Arch_Amazon-Cognito_16.png
│ │ │ ├── Arch_Amazon-Cognito_16.svg
│ │ │ ├── Arch_Amazon-Detective_16.png
│ │ │ ├── Arch_Amazon-Detective_16.svg
│ │ │ ├── Arch_Amazon-GuardDuty_16.png
│ │ │ ├── Arch_Amazon-GuardDuty_16.svg
│ │ │ ├── Arch_Amazon-Inspector_16.png
│ │ │ ├── Arch_Amazon-Inspector_16.svg
│ │ │ ├── Arch_Amazon-Macie_16.png
│ │ │ ├── Arch_Amazon-Macie_16.svg
│ │ │ ├── Arch_Amazon-Security-Lake_16.png
│ │ │ ├── Arch_Amazon-Security-Lake_16.svg
│ │ │ ├── Arch_Amazon-Verified-Permissions_16.png
│ │ │ ├── Arch_Amazon-Verified-Permissions_16.svg
│ │ │ ├── Arch_AWS-Artifact_16.png
│ │ │ ├── Arch_AWS-Artifact_16.svg
│ │ │ ├── Arch_AWS-Audit-Manager_16.png
│ │ │ ├── Arch_AWS-Audit-Manager_16.svg
│ │ │ ├── Arch_AWS-Certificate-Manager_16.png
│ │ │ ├── Arch_AWS-Certificate-Manager_16.svg
│ │ │ ├── Arch_AWS-CloudHSM_16.png
│ │ │ ├── Arch_AWS-CloudHSM_16.svg
│ │ │ ├── Arch_AWS-Directory-Service_16.png
│ │ │ ├── Arch_AWS-Directory-Service_16.svg
│ │ │ ├── Arch_AWS-Firewall-Manager_16.png
│ │ │ ├── Arch_AWS-Firewall-Manager_16.svg
│ │ │ ├── Arch_AWS-IAM-Identity-Center_16.png
│ │ │ ├── Arch_AWS-IAM-Identity-Center_16.svg
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_16.png
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_16.svg
│ │ │ ├── Arch_AWS-Key-Management-Service_16.png
│ │ │ ├── Arch_AWS-Key-Management-Service_16.svg
│ │ │ ├── Arch_AWS-Network-Firewall_16.png
│ │ │ ├── Arch_AWS-Network-Firewall_16.svg
│ │ │ ├── Arch_AWS-Payment-Cryptography_16.png
│ │ │ ├── Arch_AWS-Payment-Cryptography_16.svg
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_16.png
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_16.svg
│ │ │ ├── Arch_AWS-Resource-Access-Manager_16.png
│ │ │ ├── Arch_AWS-Resource-Access-Manager_16.svg
│ │ │ ├── Arch_AWS-Secrets-Manager_16.png
│ │ │ ├── Arch_AWS-Secrets-Manager_16.svg
│ │ │ ├── Arch_AWS-Security-Hub_16.png
│ │ │ ├── Arch_AWS-Security-Hub_16.svg
│ │ │ ├── Arch_AWS-Security-Incident-Response_16.png
│ │ │ ├── Arch_AWS-Security-Incident-Response_16.svg
│ │ │ ├── Arch_AWS-Shield_16.png
│ │ │ ├── Arch_AWS-Shield_16.svg
│ │ │ ├── Arch_AWS-Signer_16.png
│ │ │ ├── Arch_AWS-Signer_16.svg
│ │ │ ├── Arch_AWS-WAF_16.png
│ │ │ └── Arch_AWS-WAF_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Cloud-Directory_32.png
│ │ │ ├── Arch_Amazon-Cloud-Directory_32.svg
│ │ │ ├── Arch_Amazon-Cognito_32.png
│ │ │ ├── Arch_Amazon-Cognito_32.svg
│ │ │ ├── Arch_Amazon-Detective_32.png
│ │ │ ├── Arch_Amazon-Detective_32.svg
│ │ │ ├── Arch_Amazon-GuardDuty_32.png
│ │ │ ├── Arch_Amazon-GuardDuty_32.svg
│ │ │ ├── Arch_Amazon-Inspector_32.png
│ │ │ ├── Arch_Amazon-Inspector_32.svg
│ │ │ ├── Arch_Amazon-Macie_32.png
│ │ │ ├── Arch_Amazon-Macie_32.svg
│ │ │ ├── Arch_Amazon-Security-Lake_32.png
│ │ │ ├── Arch_Amazon-Security-Lake_32.svg
│ │ │ ├── Arch_Amazon-Verified-Permissions_32.png
│ │ │ ├── Arch_Amazon-Verified-Permissions_32.svg
│ │ │ ├── Arch_AWS-Artifact_32.png
│ │ │ ├── Arch_AWS-Artifact_32.svg
│ │ │ ├── Arch_AWS-Audit-Manager_32.png
│ │ │ ├── Arch_AWS-Audit-Manager_32.svg
│ │ │ ├── Arch_AWS-Certificate-Manager_32.png
│ │ │ ├── Arch_AWS-Certificate-Manager_32.svg
│ │ │ ├── Arch_AWS-CloudHSM_32.png
│ │ │ ├── Arch_AWS-CloudHSM_32.svg
│ │ │ ├── Arch_AWS-Directory-Service_32.png
│ │ │ ├── Arch_AWS-Directory-Service_32.svg
│ │ │ ├── Arch_AWS-Firewall-Manager_32.png
│ │ │ ├── Arch_AWS-Firewall-Manager_32.svg
│ │ │ ├── Arch_AWS-IAM-Identity-Center_32.png
│ │ │ ├── Arch_AWS-IAM-Identity-Center_32.svg
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_32.png
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_32.svg
│ │ │ ├── Arch_AWS-Key-Management-Service_32.png
│ │ │ ├── Arch_AWS-Key-Management-Service_32.svg
│ │ │ ├── Arch_AWS-Network-Firewall_32.png
│ │ │ ├── Arch_AWS-Network-Firewall_32.svg
│ │ │ ├── Arch_AWS-Payment-Cryptography_32.png
│ │ │ ├── Arch_AWS-Payment-Cryptography_32.svg
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_32.png
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_32.svg
│ │ │ ├── Arch_AWS-Resource-Access-Manager_32.png
│ │ │ ├── Arch_AWS-Resource-Access-Manager_32.svg
│ │ │ ├── Arch_AWS-Secrets-Manager_32.png
│ │ │ ├── Arch_AWS-Secrets-Manager_32.svg
│ │ │ ├── Arch_AWS-Security-Hub_32.png
│ │ │ ├── Arch_AWS-Security-Hub_32.svg
│ │ │ ├── Arch_AWS-Security-Incident-Response_32.png
│ │ │ ├── Arch_AWS-Security-Incident-Response_32.svg
│ │ │ ├── Arch_AWS-Shield_32.png
│ │ │ ├── Arch_AWS-Shield_32.svg
│ │ │ ├── Arch_AWS-Signer_32.png
│ │ │ ├── Arch_AWS-Signer_32.svg
│ │ │ ├── Arch_AWS-WAF_32.png
│ │ │ └── Arch_AWS-WAF_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Cloud-Directory_48.png
│ │ │ ├── Arch_Amazon-Cloud-Directory_48.svg
│ │ │ ├── Arch_Amazon-Cognito_48.png
│ │ │ ├── Arch_Amazon-Cognito_48.svg
│ │ │ ├── Arch_Amazon-Detective_48.png
│ │ │ ├── Arch_Amazon-Detective_48.svg
│ │ │ ├── Arch_Amazon-GuardDuty_48.png
│ │ │ ├── Arch_Amazon-GuardDuty_48.svg
│ │ │ ├── Arch_Amazon-Inspector_48.png
│ │ │ ├── Arch_Amazon-Inspector_48.svg
│ │ │ ├── Arch_Amazon-Macie_48.png
│ │ │ ├── Arch_Amazon-Macie_48.svg
│ │ │ ├── Arch_Amazon-Security-Lake_48.png
│ │ │ ├── Arch_Amazon-Security-Lake_48.svg
│ │ │ ├── Arch_Amazon-Verified-Permissions_48.png
│ │ │ ├── Arch_Amazon-Verified-Permissions_48.svg
│ │ │ ├── Arch_AWS-Artifact_48.png
│ │ │ ├── Arch_AWS-Artifact_48.svg
│ │ │ ├── Arch_AWS-Audit-Manager_48.png
│ │ │ ├── Arch_AWS-Audit-Manager_48.svg
│ │ │ ├── Arch_AWS-Certificate-Manager_48.png
│ │ │ ├── Arch_AWS-Certificate-Manager_48.svg
│ │ │ ├── Arch_AWS-CloudHSM_48.png
│ │ │ ├── Arch_AWS-CloudHSM_48.svg
│ │ │ ├── Arch_AWS-Directory-Service_48.png
│ │ │ ├── Arch_AWS-Directory-Service_48.svg
│ │ │ ├── Arch_AWS-Firewall-Manager_48.png
│ │ │ ├── Arch_AWS-Firewall-Manager_48.svg
│ │ │ ├── Arch_AWS-IAM-Identity-Center_48.png
│ │ │ ├── Arch_AWS-IAM-Identity-Center_48.svg
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_48.png
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_48.svg
│ │ │ ├── Arch_AWS-Key-Management-Service_48.png
│ │ │ ├── Arch_AWS-Key-Management-Service_48.svg
│ │ │ ├── Arch_AWS-Network-Firewall_48.png
│ │ │ ├── Arch_AWS-Network-Firewall_48.svg
│ │ │ ├── Arch_AWS-Payment-Cryptography_48.png
│ │ │ ├── Arch_AWS-Payment-Cryptography_48.svg
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_48.png
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_48.svg
│ │ │ ├── Arch_AWS-Resource-Access-Manager_48.png
│ │ │ ├── Arch_AWS-Resource-Access-Manager_48.svg
│ │ │ ├── Arch_AWS-Secrets-Manager_48.png
│ │ │ ├── Arch_AWS-Secrets-Manager_48.svg
│ │ │ ├── Arch_AWS-Security-Hub_48.png
│ │ │ ├── Arch_AWS-Security-Hub_48.svg
│ │ │ ├── Arch_AWS-Security-Incident-Response_48.png
│ │ │ ├── Arch_AWS-Security-Incident-Response_48.svg
│ │ │ ├── Arch_AWS-Shield_48.png
│ │ │ ├── Arch_AWS-Shield_48.svg
│ │ │ ├── Arch_AWS-Signer_48.png
│ │ │ ├── Arch_AWS-Signer_48.svg
│ │ │ ├── Arch_AWS-WAF_48.png
│ │ │ └── Arch_AWS-WAF_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Cloud-Directory_64.png
│ │ ├── Arch_Amazon-Cloud-Directory_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Cognito_64.png
│ │ ├── Arch_Amazon-Cognito_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Detective_64.png
│ │ ├── Arch_Amazon-Detective_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-GuardDuty_64.png
│ │ ├── Arch_Amazon-GuardDuty_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Inspector_64.png
│ │ ├── Arch_Amazon-Inspector_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Macie_64.png
│ │ ├── Arch_Amazon-Macie_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Security-Lake_64.png
│ │ ├── Arch_Amazon-Security-Lake_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Verified-Permissions_64.png
│ │ ├── Arch_Amazon-Verified-Permissions_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Artifact_64.png
│ │ ├── Arch_AWS-Artifact_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Audit-Manager_64.png
│ │ ├── Arch_AWS-Audit-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Certificate-Manager_64.png
│ │ ├── Arch_AWS-Certificate-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudHSM_64.png
│ │ ├── Arch_AWS-CloudHSM_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Directory-Service_64.png
│ │ ├── Arch_AWS-Directory-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Firewall-Manager_64.png
│ │ ├── Arch_AWS-Firewall-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IAM-Identity-Center_64.png
│ │ ├── Arch_AWS-IAM-Identity-Center_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Identity-and-Access-Management_64.png
│ │ ├── Arch_AWS-Identity-and-Access-Management_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Key-Management-Service_64.png
│ │ ├── Arch_AWS-Key-Management-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Network-Firewall_64.png
│ │ ├── Arch_AWS-Network-Firewall_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Payment-Cryptography_64.png
│ │ ├── Arch_AWS-Payment-Cryptography_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Private-Certificate-Authority_64.png
│ │ ├── Arch_AWS-Private-Certificate-Authority_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Resource-Access-Manager_64.png
│ │ ├── Arch_AWS-Resource-Access-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Secrets-Manager_64.png
│ │ ├── Arch_AWS-Secrets-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Security-Hub_64.png
│ │ ├── Arch_AWS-Security-Hub_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Security-Incident-Response_64.png
│ │ ├── Arch_AWS-Security-Incident-Response_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Shield_64.png
│ │ ├── Arch_AWS-Shield_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Signer_64.png
│ │ ├── Arch_AWS-Signer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-WAF_64.png
│ │ ├── Arch_AWS-WAF_64.svg
│ │ └── [email protected]
│ └── storage
│ ├── .DS_Store
│ ├── 16
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-EFS_16.png
│ │ ├── Arch_Amazon-EFS_16.svg
│ │ ├── Arch_Amazon-Elastic-Block-Store_16.png
│ │ ├── Arch_Amazon-Elastic-Block-Store_16.svg
│ │ ├── Arch_Amazon-File-Cache_16.png
│ │ ├── Arch_Amazon-File-Cache_16.svg
│ │ ├── Arch_Amazon-FSx_16.png
│ │ ├── Arch_Amazon-FSx_16.svg
│ │ ├── Arch_Amazon-FSx-for-Lustre_16.png
│ │ ├── Arch_Amazon-FSx-for-Lustre_16.svg
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_16.png
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_16.svg
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_16.png
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_16.svg
│ │ ├── Arch_Amazon-FSx-for-WFS_16.png
│ │ ├── Arch_Amazon-FSx-for-WFS_16.svg
│ │ ├── Arch_Amazon-S3-on-Outposts_16.png
│ │ ├── Arch_Amazon-S3-on-Outposts_16.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service_16.png
│ │ ├── Arch_Amazon-Simple-Storage-Service_16.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_16.png
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_16.svg
│ │ ├── Arch_AWS-Backup_16.png
│ │ ├── Arch_AWS-Backup_16.svg
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_16.png
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_16.svg
│ │ ├── Arch_AWS-Snowball_16.png
│ │ ├── Arch_AWS-Snowball_16.svg
│ │ ├── Arch_AWS-Snowball-Edge_16.png
│ │ ├── Arch_AWS-Snowball-Edge_16.svg
│ │ ├── Arch_AWS-Storage-Gateway_16.png
│ │ └── Arch_AWS-Storage-Gateway_16.svg
│ ├── 32
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-EFS_32.png
│ │ ├── Arch_Amazon-EFS_32.svg
│ │ ├── Arch_Amazon-Elastic-Block-Store_32.png
│ │ ├── Arch_Amazon-Elastic-Block-Store_32.svg
│ │ ├── Arch_Amazon-File-Cache_32.png
│ │ ├── Arch_Amazon-File-Cache_32.svg
│ │ ├── Arch_Amazon-FSx_32.png
│ │ ├── Arch_Amazon-FSx_32.svg
│ │ ├── Arch_Amazon-FSx-for-Lustre_32.png
│ │ ├── Arch_Amazon-FSx-for-Lustre_32.svg
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_32.png
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_32.svg
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_32.png
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_32.svg
│ │ ├── Arch_Amazon-FSx-for-WFS_32.png
│ │ ├── Arch_Amazon-FSx-for-WFS_32.svg
│ │ ├── Arch_Amazon-S3-on-Outposts_32.png
│ │ ├── Arch_Amazon-S3-on-Outposts_32.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service_32.png
│ │ ├── Arch_Amazon-Simple-Storage-Service_32.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_32.png
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_32.svg
│ │ ├── Arch_AWS-Backup_32.png
│ │ ├── Arch_AWS-Backup_32.svg
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_32.png
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_32.svg
│ │ ├── Arch_AWS-Snowball_32.png
│ │ ├── Arch_AWS-Snowball_32.svg
│ │ ├── Arch_AWS-Snowball-Edge_32.png
│ │ ├── Arch_AWS-Snowball-Edge_32.svg
│ │ ├── Arch_AWS-Storage-Gateway_32.png
│ │ └── Arch_AWS-Storage-Gateway_32.svg
│ ├── 48
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-EFS_48.png
│ │ ├── Arch_Amazon-EFS_48.svg
│ │ ├── Arch_Amazon-Elastic-Block-Store_48.png
│ │ ├── Arch_Amazon-Elastic-Block-Store_48.svg
│ │ ├── Arch_Amazon-File-Cache_48.png
│ │ ├── Arch_Amazon-File-Cache_48.svg
│ │ ├── Arch_Amazon-FSx_48.png
│ │ ├── Arch_Amazon-FSx_48.svg
│ │ ├── Arch_Amazon-FSx-for-Lustre_48.png
│ │ ├── Arch_Amazon-FSx-for-Lustre_48.svg
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_48.png
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_48.svg
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_48.png
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_48.svg
│ │ ├── Arch_Amazon-FSx-for-WFS_48.png
│ │ ├── Arch_Amazon-FSx-for-WFS_48.svg
│ │ ├── Arch_Amazon-S3-on-Outposts_48.png
│ │ ├── Arch_Amazon-S3-on-Outposts_48.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service_48.png
│ │ ├── Arch_Amazon-Simple-Storage-Service_48.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_48.png
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_48.svg
│ │ ├── Arch_AWS-Backup_48.png
│ │ ├── Arch_AWS-Backup_48.svg
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_48.png
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_48.svg
│ │ ├── Arch_AWS-Snowball_48.png
│ │ ├── Arch_AWS-Snowball_48.svg
│ │ ├── Arch_AWS-Snowball-Edge_48.png
│ │ ├── Arch_AWS-Snowball-Edge_48.svg
│ │ ├── Arch_AWS-Storage-Gateway_48.png
│ │ └── Arch_AWS-Storage-Gateway_48.svg
│ └── 64
│ ├── .DS_Store
│ ├── Arch_Amazon-EFS_64.png
│ ├── Arch_Amazon-EFS_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-Elastic-Block-Store_64.png
│ ├── Arch_Amazon-Elastic-Block-Store_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-File-Cache_64.png
│ ├── Arch_Amazon-File-Cache_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx_64.png
│ ├── Arch_Amazon-FSx_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-Lustre_64.png
│ ├── Arch_Amazon-FSx-for-Lustre_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_64.png
│ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-OpenZFS_64.png
│ ├── Arch_Amazon-FSx-for-OpenZFS_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-WFS_64.png
│ ├── Arch_Amazon-FSx-for-WFS_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-S3-on-Outposts_64.png
│ ├── Arch_Amazon-S3-on-Outposts_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-Simple-Storage-Service_64.png
│ ├── Arch_Amazon-Simple-Storage-Service_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-Simple-Storage-Service-Glacier_64.png
│ ├── Arch_Amazon-Simple-Storage-Service-Glacier_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Backup_64.png
│ ├── Arch_AWS-Backup_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Elastic-Disaster-Recovery_64.png
│ ├── Arch_AWS-Elastic-Disaster-Recovery_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Snowball_64.png
│ ├── Arch_AWS-Snowball_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Snowball-Edge_64.png
│ ├── Arch_AWS-Snowball-Edge_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Storage-Gateway_64.png
│ ├── Arch_AWS-Storage-Gateway_64.svg
│ └── [email protected]
├── index.html
├── manifest.json
├── mocks
│ ├── mock-discovery-live.json
│ └── mock-generate-graph.json
├── robots.txt
└── static
├── css
│ ├── main.f8f47ec8.css
│ └── main.f8f47ec8.css.map
└── js
├── 1297.c349ec3c.chunk.js
├── 14.7ba48ec4.chunk.js
├── 14.7ba48ec4.chunk.js.LICENSE.txt
├── 14.7ba48ec4.chunk.js.map
├── 1409.d2c5ac18.chunk.js
├── 1457.10b2696f.chunk.js
├── 1595.2e8c74e3.chunk.js
├── 1595.2e8c74e3.chunk.js.LICENSE.txt
├── 1595.2e8c74e3.chunk.js.map
├── 1707.279d4917.chunk.js
├── 1707.279d4917.chunk.js.map
├── 2019.3e4e6398.chunk.js
├── 2019.3e4e6398.chunk.js.map
├── 2038.86d3ba27.chunk.js
├── 2038.86d3ba27.chunk.js.map
├── 2374.220d0c1c.chunk.js
├── 2374.220d0c1c.chunk.js.LICENSE.txt
├── 2374.220d0c1c.chunk.js.map
├── 2491.6dc3b41c.chunk.js
├── 2491.6dc3b41c.chunk.js.map
├── 3025.e856e271.chunk.js
├── 3025.e856e271.chunk.js.LICENSE.txt
├── 3025.e856e271.chunk.js.map
├── 3119.2c9023ad.chunk.js
├── 3119.2c9023ad.chunk.js.LICENSE.txt
├── 3119.2c9023ad.chunk.js.map
├── 3290.6c752b7b.chunk.js
├── 3290.6c752b7b.chunk.js.map
├── 3345.719283e7.chunk.js
├── 3345.719283e7.chunk.js.map
├── 349.2456c1b6.chunk.js
├── 349.2456c1b6.chunk.js.map
├── 3641.87d0bf7c.chunk.js
├── 3641.87d0bf7c.chunk.js.map
├── 3705.1bb92025.chunk.js
├── 3705.1bb92025.chunk.js.map
├── 3750.c184e3e3.chunk.js
├── 3750.c184e3e3.chunk.js.map
├── 3817.79a57e5e.chunk.js
├── 3817.79a57e5e.chunk.js.map
├── 4114.eea3c770.chunk.js
├── 4114.eea3c770.chunk.js.map
├── 4135.b88aaf7b.chunk.js
├── 4147.5f8e8649.chunk.js
├── 4191.3ed02494.chunk.js
├── 4191.3ed02494.chunk.js.map
├── 4487.fec1d877.chunk.js
├── 4570.ce64aedb.chunk.js
├── 4570.ce64aedb.chunk.js.map
├── 490.a05b6059.chunk.js
├── 490.a05b6059.chunk.js.map
├── 5009.1a2aa685.chunk.js
├── 5009.1a2aa685.chunk.js.LICENSE.txt
├── 5009.1a2aa685.chunk.js.map
├── 5502.14766ceb.chunk.js
├── 5502.14766ceb.chunk.js.map
├── 62.b40b6fbd.chunk.js
├── 62.b40b6fbd.chunk.js.map
├── 6453.8c3fba0e.chunk.js
├── 6453.8c3fba0e.chunk.js.map
├── 6455.8e6b5278.chunk.js
├── 6455.8e6b5278.chunk.js.map
├── 646.6aac5035.chunk.js
├── 646.6aac5035.chunk.js.LICENSE.txt
├── 646.6aac5035.chunk.js.map
├── 6516.3948f7b4.chunk.js
├── 6516.3948f7b4.chunk.js.map
├── 6725.6ad72d9d.chunk.js
├── 6823.e10e9817.chunk.js
├── 6823.e10e9817.chunk.js.map
├── 6865.afd592a9.chunk.js
├── 6865.afd592a9.chunk.js.map
├── 6977.4218876a.chunk.js
├── 6977.4218876a.chunk.js.LICENSE.txt
├── 6977.4218876a.chunk.js.map
├── 7069.6c60b97c.chunk.js
├── 7069.6c60b97c.chunk.js.map
├── 7513.37f12f0e.chunk.js
├── 7513.37f12f0e.chunk.js.map
├── 7550.0cfdabcf.chunk.js
├── 7550.0cfdabcf.chunk.js.map
├── 7841.37a92b31.chunk.js
├── 7841.37a92b31.chunk.js.map
├── 7854.ed7e04cc.chunk.js
├── 7854.ed7e04cc.chunk.js.map
├── 8151.87df400e.chunk.js
├── 8151.87df400e.chunk.js.map
├── 8195.55a334cf.chunk.js
├── 8195.55a334cf.chunk.js.map
├── 8218.b7de3259.chunk.js
├── 8218.b7de3259.chunk.js.map
├── 8234.f2f9a7db.chunk.js
├── 8234.f2f9a7db.chunk.js.map
├── 8332.9aa74d00.chunk.js
├── 8332.9aa74d00.chunk.js.map
├── 8449.676bcc94.chunk.js
├── 8449.676bcc94.chunk.js.map
├── 8660.1c56263e.chunk.js
├── 8660.1c56263e.chunk.js.map
├── 9413.aea20916.chunk.js
├── 9413.aea20916.chunk.js.map
├── 9448.cd4e8095.chunk.js
├── 9448.cd4e8095.chunk.js.map
├── 9459.753274fe.chunk.js
├── 9459.753274fe.chunk.js.map
├── 9573.5ba95804.chunk.js
├── 9573.5ba95804.chunk.js.map
├── 9664.9e69f3bc.chunk.js
├── 9664.9e69f3bc.chunk.js.map
├── 9844.6366c533.chunk.js
├── 9844.6366c533.chunk.js.map
├── main.af8efd6b.js
├── main.af8efd6b.js.LICENSE.txt
└── main.af8efd6b.js.map
```
# Files
--------------------------------------------------------------------------------
/pkg/agent/agent_plan_executor.go:
--------------------------------------------------------------------------------
```go
1 | package agent
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "strings"
8 | "time"
9 |
10 | "github.com/google/uuid"
11 | "github.com/versus-control/ai-infrastructure-agent/pkg/types"
12 | )
13 |
14 | // ========== Interface defines ==========
15 |
16 | // PlanExecutorInterface defines plan execution functionality
17 | //
18 | // Available Functions:
19 | // - ExecuteConfirmedPlanWithDryRun() : Execute confirmed plans with dry-run support
20 | // - SimulatePlanExecution() : Simulate plan execution for dry-run mode
21 | // - executeExecutionStep() : Execute individual plan steps
22 | // - executeCreateAction() : Execute create actions via MCP tools
23 | // - executeQueryAction() : Execute query actions via MCP tools
24 | // - executeNativeMCPTool() : Execute native MCP tool calls
25 | // - executeUpdateAction() : Execute update actions on existing resources
26 | // - executeDeleteAction() : Execute delete actions on resources
27 | // - executeValidateAction() : Execute validation actions
28 | // - updateStateFromMCPResult() : Update state from MCP operation results
29 | // - extractResourceTypeFromStep() : Extract resource type from execution step
30 | // - getAvailableToolsContext() : Get available tools context for AI prompts
31 | // - persistCurrentState() : Persist current state to storage
32 | // - extractResourceIDFromResponse() : Extract AWS resource IDs from responses
33 | // - waitForResourceReady() : Wait for AWS resources to be ready before continuing
34 | // - checkResourceState() : Check if a specific AWS resource is ready
35 | // - checkNATGatewayState() : Check if NAT gateway is available
36 | // - checkRDSInstanceState() : Check if RDS instance is available
37 | // - storeResourceMapping() : Store step-to-resource ID mappings
38 | //
39 | // This file manages the execution of infrastructure plans, including dry-run
40 | // capabilities, progress tracking, and state management integration.
41 | //
42 | // Usage Example:
43 | // 1. execution := agent.ExecuteConfirmedPlanWithDryRun(ctx, decision, progressChan, false)
44 | // 2. // Monitor execution through progressChan updates
45 |
46 | // ========== Plan-Level Recovery Implementation ==========
47 |
48 | // ExecutePlanWithReActRecovery executes a plan with plan-level ReAct recovery
49 | // This is the NEW plan-level recovery method that replaces step-level recovery
50 | func (a *StateAwareAgent) ExecutePlanWithReActRecovery(
51 | ctx context.Context,
52 | decision *types.AgentDecision,
53 | progressChan chan<- *types.ExecutionUpdate,
54 | coordinator PlanRecoveryCoordinator,
55 | ) (*types.PlanExecution, error) {
56 | a.Logger.WithFields(map[string]interface{}{
57 | "decision_id": decision.ID,
58 | "action": decision.Action,
59 | "plan_steps": len(decision.ExecutionPlan),
60 | }).Info("Executing plan with plan-level ReAct recovery")
61 |
62 | // Create execution plan
63 | execution := &types.PlanExecution{
64 | ID: uuid.New().String(),
65 | Name: fmt.Sprintf("Execute %s", decision.Action),
66 | Status: "running",
67 | StartedAt: time.Now(),
68 | Steps: []*types.ExecutionStep{},
69 | Changes: []*types.ChangeDetection{},
70 | Errors: []string{},
71 | }
72 |
73 | // Send initial progress update
74 | if progressChan != nil {
75 | progressChan <- &types.ExecutionUpdate{
76 | Type: "execution_started",
77 | ExecutionID: execution.ID,
78 | Message: "Starting plan execution with ReAct recovery",
79 | Timestamp: time.Now(),
80 | }
81 | }
82 |
83 | // Get recovery configuration
84 | config := DefaultPlanRecoveryConfig(coordinator)
85 |
86 | // Attempt execution with recovery (up to MaxRecoveryAttempts)
87 | for attemptNumber := 1; attemptNumber <= config.MaxRecoveryAttempts; attemptNumber++ {
88 |
89 | // Execute the plan
90 | planToExecute := decision.ExecutionPlan
91 | if attemptNumber > 1 {
92 | // For retry attempts, planToExecute will be set by recovery strategy execution
93 | a.Logger.Info("This is a recovery attempt - plan should have been adjusted by previous recovery")
94 | }
95 |
96 | // Try to execute all steps
97 | failedStepIndex := -1
98 | var failureError error
99 |
100 | for i, planStep := range planToExecute {
101 | // Skip steps that are already completed (from previous recovery attempts)
102 | if planStep.Status == "completed" {
103 | a.Logger.WithFields(map[string]interface{}{
104 | "step_id": planStep.ID,
105 | "step_name": planStep.Name,
106 | "step_index": i,
107 | "attempt_number": attemptNumber,
108 | }).Debug("Skipping already completed step from recovery plan")
109 |
110 | // Don't send progress updates or execute, these were done in previous attempt
111 | continue
112 | }
113 |
114 | // Send step started update
115 | if progressChan != nil {
116 | progressChan <- &types.ExecutionUpdate{
117 | Type: "step_started",
118 | ExecutionID: execution.ID,
119 | StepID: planStep.ID,
120 | Message: fmt.Sprintf("Starting step %d/%d: %s", i+1, len(planToExecute), planStep.Name),
121 | Timestamp: time.Now(),
122 | }
123 | }
124 |
125 | // Execute the step
126 | step, err := a.executeExecutionStep(planStep, execution, progressChan)
127 |
128 | if err != nil {
129 | // Step failed
130 | step.Status = "failed"
131 | step.Error = err.Error()
132 | execution.Steps = append(execution.Steps, step)
133 |
134 | failedStepIndex = i
135 | failureError = err
136 |
137 | if progressChan != nil {
138 | progressChan <- &types.ExecutionUpdate{
139 | Type: "step_failed",
140 | ExecutionID: execution.ID,
141 | StepID: planStep.ID,
142 | Message: fmt.Sprintf("Step %d failed: %v", i+1, err),
143 | Error: err.Error(),
144 | Timestamp: time.Now(),
145 | }
146 | }
147 |
148 | break // Exit step execution loop
149 | }
150 |
151 | // Step succeeded
152 | step.Status = "completed"
153 | execution.Steps = append(execution.Steps, step)
154 |
155 | if progressChan != nil {
156 | progressChan <- &types.ExecutionUpdate{
157 | Type: "step_completed",
158 | ExecutionID: execution.ID,
159 | StepID: planStep.ID,
160 | Message: fmt.Sprintf("Step %d completed: %s", i+1, planStep.Name),
161 | Timestamp: time.Now(),
162 | }
163 | }
164 |
165 | // Add delay after successful step for smooth frontend display
166 | if a.config.StepDelayMS > 0 {
167 | time.Sleep(time.Millisecond * time.Duration(a.config.StepDelayMS))
168 | }
169 |
170 | // Persist state after successful step
171 | if err := a.persistCurrentState(); err != nil {
172 | a.Logger.WithError(err).Warn("Failed to persist state after successful step")
173 | }
174 |
175 | // Store resource mapping if resource was created
176 | if step.Output != nil {
177 | // Extract the mcp_response from the wrapped output
178 | var mcpResponse map[string]interface{}
179 | if wrapped, ok := step.Output["mcp_response"].(map[string]interface{}); ok {
180 | mcpResponse = wrapped
181 | } else {
182 | // If not wrapped, use the output directly (for backward compatibility)
183 | mcpResponse = step.Output
184 | }
185 |
186 | // Process arrays first to get concatenated values
187 | processedOutput := a.processArraysInMCPResponse(mcpResponse)
188 | if resourceID, err := a.extractResourceIDFromResponse(processedOutput, planStep.MCPTool, planStep.ID); err == nil && resourceID != "" {
189 | a.storeResourceMapping(planStep.ID, resourceID, processedOutput)
190 | }
191 | }
192 | } // Check if execution completed successfully
193 | if failedStepIndex == -1 {
194 | // All steps completed successfully
195 | execution.Status = "completed"
196 | now := time.Now()
197 | execution.CompletedAt = &now
198 |
199 | if progressChan != nil {
200 | progressChan <- &types.ExecutionUpdate{
201 | Type: "execution_completed",
202 | ExecutionID: execution.ID,
203 | Message: "Execution completed successfully",
204 | Timestamp: time.Now(),
205 | }
206 | }
207 |
208 | return execution, nil
209 | }
210 |
211 | // Execution failed - attempt recovery
212 | a.Logger.WithFields(map[string]interface{}{
213 | "execution_id": execution.ID,
214 | "failed_step_index": failedStepIndex,
215 | "attempt_number": attemptNumber,
216 | }).Warn("Plan execution failed, attempting recovery")
217 |
218 | // Check if we've exhausted recovery attempts
219 | if attemptNumber >= config.MaxRecoveryAttempts {
220 | execution.Status = "failed"
221 | execution.Errors = append(execution.Errors,
222 | fmt.Sprintf("Execution failed after %d attempts: %v", attemptNumber, failureError))
223 | now := time.Now()
224 | execution.CompletedAt = &now
225 |
226 | if progressChan != nil {
227 | progressChan <- &types.ExecutionUpdate{
228 | Type: "execution_failed",
229 | ExecutionID: execution.ID,
230 | Message: fmt.Sprintf("Execution failed after %d recovery attempts", attemptNumber),
231 | Error: failureError.Error(),
232 | Timestamp: time.Now(),
233 | }
234 | }
235 |
236 | return execution, fmt.Errorf("execution failed after %d attempts: %w", attemptNumber, failureError)
237 | }
238 |
239 | // Extract user intent safely with fallback
240 | userIntent := ""
241 | if decision.Parameters != nil {
242 | if intent, ok := decision.Parameters["user_intent"].(string); ok {
243 | userIntent = intent
244 | }
245 | }
246 | // Fallback to reasoning if user_intent is not available
247 | if userIntent == "" {
248 | userIntent = decision.Reasoning
249 | }
250 |
251 | // Build failure context
252 | failureContext := a.buildPlanFailureContext(
253 | execution,
254 | failedStepIndex,
255 | planToExecute[failedStepIndex],
256 | failureError,
257 | decision.ExecutionPlan,
258 | decision.Action,
259 | userIntent,
260 | attemptNumber,
261 | )
262 |
263 | // Notify UI that we're analyzing recovery options
264 | if progressChan != nil {
265 | progressChan <- &types.ExecutionUpdate{
266 | Type: "plan_recovery_analyzing",
267 | ExecutionID: execution.ID,
268 | StepID: planToExecute[failedStepIndex].ID,
269 | Message: fmt.Sprintf("Plan failed at step %d, analyzing recovery options...", failedStepIndex+1),
270 | Timestamp: time.Now(),
271 | }
272 | }
273 |
274 | if coordinator != nil {
275 | coordinator.NotifyRecoveryAnalyzing(
276 | execution.ID,
277 | planToExecute[failedStepIndex].ID,
278 | failedStepIndex,
279 | len(execution.Steps)-1, // Completed steps (excluding failed one)
280 | len(planToExecute),
281 | )
282 | }
283 |
284 | // Consult AI for recovery strategy
285 | analysis, err := a.ConsultAIForPlanRecovery(ctx, failureContext)
286 | if err != nil {
287 | a.Logger.WithError(err).Error("Failed to get AI recovery analysis")
288 | // Continue to next attempt without recovery strategy
289 | continue
290 | }
291 |
292 | // NOTE: Don't send a separate progress update here - RequestPlanRecoveryDecision will send the full recovery plan
293 | // Sending a duplicate message would overwrite the complete plan in the frontend
294 |
295 | // Request user approval via coordinator (this sends the full recovery plan to UI)
296 | approved, err := coordinator.RequestPlanRecoveryDecision(
297 | execution.ID,
298 | failureContext,
299 | analysis.Strategy,
300 | )
301 |
302 | if err != nil {
303 | a.Logger.WithError(err).Error("Failed to get recovery decision from user")
304 | return execution, fmt.Errorf("recovery decision failed: %w", err)
305 | }
306 |
307 | if !approved {
308 | // User rejected the recovery plan
309 | execution.Status = "aborted"
310 | now := time.Now()
311 | execution.CompletedAt = &now
312 |
313 | if progressChan != nil {
314 | progressChan <- &types.ExecutionUpdate{
315 | Type: "execution_aborted",
316 | ExecutionID: execution.ID,
317 | Message: "Execution aborted by user",
318 | Timestamp: time.Now(),
319 | }
320 | }
321 |
322 | return execution, fmt.Errorf("execution aborted by user")
323 | }
324 |
325 | // Execute the approved recovery strategy
326 | recoveryStrategy := analysis.Strategy
327 |
328 | if progressChan != nil {
329 | progressChan <- &types.ExecutionUpdate{
330 | Type: "plan_recovery_executing",
331 | ExecutionID: execution.ID,
332 | Message: fmt.Sprintf("Executing recovery plan with %d steps", len(recoveryStrategy.ExecutionPlan)),
333 | Timestamp: time.Now(),
334 | }
335 | }
336 |
337 | if coordinator != nil {
338 | coordinator.NotifyRecoveryExecuting(execution.ID, recoveryStrategy)
339 | }
340 |
341 | // Execute the recovery strategy
342 | recoveryResult, err := a.ExecuteRecoveryStrategy(ctx, recoveryStrategy, failureContext, progressChan)
343 | if err != nil {
344 | a.Logger.WithError(err).Error("Recovery strategy execution failed")
345 |
346 | if coordinator != nil {
347 | coordinator.NotifyRecoveryFailed(execution.ID, err.Error())
348 | }
349 |
350 | // Continue to next recovery attempt
351 | continue
352 | }
353 |
354 | if progressChan != nil {
355 | progressChan <- &types.ExecutionUpdate{
356 | Type: "plan_recovery_completed",
357 | ExecutionID: execution.ID,
358 | Message: "Recovery completed, continuing execution",
359 | Timestamp: time.Now(),
360 | }
361 | }
362 |
363 | if coordinator != nil {
364 | coordinator.NotifyRecoveryCompleted(execution.ID)
365 | }
366 |
367 | // Update execution with recovery steps
368 | execution.Steps = append(execution.Steps, recoveryResult.CompletedSteps...)
369 |
370 | // Recovery completed successfully - execution is done
371 | // ExecuteRecoveryStrategy has already executed the complete plan
372 | // (completed steps + recovery steps + remaining steps)
373 | execution.Status = "completed"
374 | now := time.Now()
375 | execution.CompletedAt = &now
376 |
377 | a.Logger.WithFields(map[string]interface{}{
378 | "execution_id": execution.ID,
379 | "recovery_steps": len(recoveryResult.CompletedSteps),
380 | "total_steps": len(execution.Steps),
381 | "attempt_number": attemptNumber,
382 | }).Info("Recovery strategy completed successfully, execution finished")
383 |
384 | // Notify completion via WebSocket
385 | if progressChan != nil {
386 | progressChan <- &types.ExecutionUpdate{
387 | Type: "execution_completed",
388 | ExecutionID: execution.ID,
389 | Message: fmt.Sprintf("Execution completed after recovery (attempt %d/%d)", attemptNumber, config.MaxRecoveryAttempts),
390 | Timestamp: time.Now(),
391 | }
392 | }
393 |
394 | return execution, nil
395 | }
396 |
397 | // Should not reach here
398 | execution.Status = "failed"
399 | now := time.Now()
400 | execution.CompletedAt = &now
401 | return execution, fmt.Errorf("execution failed - max recovery attempts exhausted")
402 | }
403 |
404 | // ConsultAIForPlanRecovery asks the AI model for plan-level recovery strategies
405 | func (a *StateAwareAgent) ConsultAIForPlanRecovery(
406 | ctx context.Context,
407 | failureContext *PlanFailureContext,
408 | ) (*AIPlanRecoveryAnalysis, error) {
409 | a.Logger.WithField("execution_id", failureContext.ExecutionID).Info("Consulting AI for plan recovery strategies")
410 |
411 | // Create recovery engine
412 | engine := NewPlanRecoveryEngine(a)
413 |
414 | // Analyze the failure
415 | analysis, err := engine.AnalyzePlanFailure(ctx, failureContext)
416 | if err != nil {
417 | return nil, fmt.Errorf("AI analysis failed: %w", err)
418 | }
419 |
420 | return analysis, nil
421 | }
422 |
423 | // ExecuteRecoveryStrategy executes a selected recovery strategy
424 | func (a *StateAwareAgent) ExecuteRecoveryStrategy(
425 | ctx context.Context,
426 | strategy *PlanRecoveryStrategy,
427 | failureContext *PlanFailureContext,
428 | progressChan chan<- *types.ExecutionUpdate,
429 | ) (*PlanRecoveryResult, error) {
430 |
431 | startTime := time.Now()
432 | result := &PlanRecoveryResult{
433 | Success: false,
434 | SelectedStrategy: strategy,
435 | AttemptNumber: failureContext.AttemptNumber,
436 | CompletedSteps: []*types.ExecutionStep{},
437 | }
438 |
439 | // Execute recovery plan steps (already in standard ExecutionPlanStep format)
440 | for i, planStep := range strategy.ExecutionPlan {
441 | // Skip steps that are already completed (preserved from original execution)
442 | if planStep.Status == "completed" {
443 | a.Logger.WithFields(map[string]interface{}{
444 | "step_id": planStep.ID,
445 | "step_name": planStep.Name,
446 | "step_index": i,
447 | "total_steps": len(strategy.ExecutionPlan),
448 | "execution_id": failureContext.ExecutionID,
449 | "attempt_number": failureContext.AttemptNumber,
450 | }).Info("✅ Skipping already completed step in recovery plan execution")
451 |
452 | // Don't add to result.CompletedSteps since it's from original execution
453 | // These are just for UI context, not part of recovery execution
454 | continue
455 | }
456 |
457 | // Send step started update (same as main execution loop)
458 | if progressChan != nil {
459 | progressChan <- &types.ExecutionUpdate{
460 | Type: "step_started",
461 | ExecutionID: failureContext.ExecutionID,
462 | StepID: planStep.ID,
463 | Message: fmt.Sprintf("Starting recovery step %d/%d: %s", i+1, len(strategy.ExecutionPlan), planStep.Name),
464 | Timestamp: time.Now(),
465 | }
466 | }
467 |
468 | // Create temporary execution for this recovery step
469 | tempExecution := &types.PlanExecution{
470 | ID: failureContext.ExecutionID + "-recovery",
471 | Status: "running",
472 | }
473 |
474 | // Execute the step
475 | step, err := a.executeExecutionStep(planStep, tempExecution, progressChan)
476 | if err != nil {
477 | result.Success = false
478 | result.FailureReason = fmt.Sprintf("Recovery step %s failed: %v", planStep.ID, err)
479 | result.Duration = time.Since(startTime)
480 |
481 | // Send step failed update (same as main execution loop)
482 | if progressChan != nil {
483 | progressChan <- &types.ExecutionUpdate{
484 | Type: "step_failed",
485 | ExecutionID: failureContext.ExecutionID,
486 | StepID: planStep.ID,
487 | Message: fmt.Sprintf("Recovery step failed: %v", err),
488 | Error: err.Error(),
489 | Timestamp: time.Now(),
490 | }
491 | }
492 |
493 | a.Logger.WithError(err).WithField("step_id", planStep.ID).Error("Recovery step failed")
494 | return result, fmt.Errorf("recovery step failed: %w", err)
495 | }
496 |
497 | step.Status = "completed"
498 | result.CompletedSteps = append(result.CompletedSteps, step)
499 |
500 | // Send step completed update (same as main execution loop)
501 | if progressChan != nil {
502 | progressChan <- &types.ExecutionUpdate{
503 | Type: "step_completed",
504 | ExecutionID: failureContext.ExecutionID,
505 | StepID: planStep.ID,
506 | Message: fmt.Sprintf("Completed recovery step %d/%d: %s", i+1, len(strategy.ExecutionPlan), planStep.Name),
507 | Timestamp: time.Now(),
508 | }
509 | }
510 |
511 | // Persist state after each successful recovery step
512 | if err := a.persistCurrentState(); err != nil {
513 | a.Logger.WithError(err).Warn("Failed to persist state after recovery step")
514 | }
515 |
516 | // Store resource mapping if resource was created
517 | if step.Output != nil {
518 | // Extract the mcp_response from the wrapped output
519 | var mcpResponse map[string]interface{}
520 | if wrapped, ok := step.Output["mcp_response"].(map[string]interface{}); ok {
521 | mcpResponse = wrapped
522 | } else {
523 | // If not wrapped, use the output directly (for backward compatibility)
524 | mcpResponse = step.Output
525 | }
526 |
527 | // Process arrays first to get concatenated values
528 | processedOutput := a.processArraysInMCPResponse(mcpResponse)
529 | if resourceID, err := a.extractResourceIDFromResponse(processedOutput, planStep.MCPTool, planStep.ID); err == nil && resourceID != "" {
530 | a.storeResourceMapping(planStep.ID, resourceID, processedOutput)
531 | result.NewResourcesCreated = append(result.NewResourcesCreated, resourceID)
532 | }
533 | }
534 | }
535 |
536 | // Recovery completed successfully
537 | result.Success = true
538 | result.Duration = time.Since(startTime)
539 |
540 | a.Logger.WithFields(map[string]interface{}{
541 | "execution_id": failureContext.ExecutionID,
542 | "recovery_steps": len(result.CompletedSteps),
543 | "new_resources": len(result.NewResourcesCreated),
544 | "duration_seconds": result.Duration.Seconds(),
545 | }).Info("Recovery strategy executed successfully")
546 |
547 | return result, nil
548 | }
549 |
550 | // buildPlanFailureContext creates a PlanFailureContext from execution state
551 | func (a *StateAwareAgent) buildPlanFailureContext(
552 | execution *types.PlanExecution,
553 | failedStepIndex int,
554 | failedStep *types.ExecutionPlanStep,
555 | failureError error,
556 | originalPlan []*types.ExecutionPlanStep,
557 | originalAction string,
558 | originalUserIntent string,
559 | attemptNumber int,
560 | ) *PlanFailureContext {
561 | a.Logger.WithField("failed_step_index", failedStepIndex).Debug("Building plan failure context")
562 |
563 | // Extract completed steps (all steps before the failed one)
564 | completedSteps := make([]*CompletedStepInfo, 0)
565 | for i := 0; i < failedStepIndex && i < len(execution.Steps); i++ {
566 | execStep := execution.Steps[i]
567 | if execStep.Status == "completed" {
568 | completedStep := &CompletedStepInfo{
569 | StepID: execStep.ID,
570 | StepName: execStep.Name,
571 | StepIndex: i,
572 | Status: "completed",
573 | CompletedAt: *execStep.CompletedAt,
574 | Duration: execStep.Duration,
575 | }
576 |
577 | // Preserve the full original step for recovery (CRITICAL for Action field)
578 | if i < len(originalPlan) {
579 | completedStep.OriginalStep = originalPlan[i]
580 | }
581 |
582 | // Extract resource ID if available
583 | if execStep.Output != nil {
584 | // First try to get the already-extracted resource ID from the wrapped output
585 | if resourceID, ok := execStep.Output["resource_id"].(string); ok && resourceID != "" {
586 | completedStep.ResourceID = resourceID
587 | completedStep.ResourceType = a.extractResourceTypeFromStep(originalPlan[i])
588 | } else {
589 | // Unwrap mcp_response and extract (for backward compatibility)
590 | var mcpResponse map[string]interface{}
591 | if wrapped, ok := execStep.Output["mcp_response"].(map[string]interface{}); ok {
592 | mcpResponse = wrapped
593 | } else {
594 | mcpResponse = execStep.Output
595 | }
596 |
597 | // Process arrays before extraction
598 | processedOutput := a.processArraysInMCPResponse(mcpResponse)
599 |
600 | // Try to extract resource ID from processed output
601 | if resourceID, err := a.extractResourceIDFromResponse(processedOutput, originalPlan[i].MCPTool, originalPlan[i].ID); err == nil && resourceID != "" {
602 | completedStep.ResourceID = resourceID
603 | completedStep.ResourceType = a.extractResourceTypeFromStep(originalPlan[i])
604 | }
605 | }
606 | }
607 |
608 | if execStep.Output != nil {
609 | completedStep.Output = execStep.Output
610 | }
611 |
612 | completedSteps = append(completedSteps, completedStep)
613 | }
614 | }
615 |
616 | // Extract remaining steps (all steps after the failed one)
617 | remainingSteps := make([]*types.ExecutionPlanStep, 0)
618 | for i := failedStepIndex + 1; i < len(originalPlan); i++ {
619 | remainingSteps = append(remainingSteps, originalPlan[i])
620 | }
621 |
622 | // Get resource mappings
623 | a.mappingsMutex.RLock()
624 | resourceMappings := make(map[string]string)
625 | for k, v := range a.resourceMappings {
626 | resourceMappings[k] = v
627 | }
628 | a.mappingsMutex.RUnlock()
629 |
630 | // Get current infrastructure state
631 | // Note: We're analyzing state without live scan for speed (scanLive=false)
632 | // This uses cached state which should be sufficient for recovery context
633 | currentState, _, _, err := a.AnalyzeInfrastructureState(context.Background(), false)
634 | if err != nil {
635 | a.Logger.WithError(err).Warn("Failed to get current infrastructure state, using nil")
636 | currentState = nil
637 | }
638 |
639 | // Build the context
640 | ctx := &PlanFailureContext{
641 | ExecutionID: execution.ID,
642 | ExecutionStarted: execution.StartedAt,
643 | FailedStepID: failedStep.ID,
644 | FailedStepIndex: failedStepIndex,
645 | FailedStep: failedStep,
646 | FailureError: failureError.Error(),
647 | FailureTime: time.Now(),
648 | AttemptNumber: attemptNumber,
649 | CompletedSteps: completedSteps,
650 | RemainingSteps: remainingSteps,
651 | CurrentState: currentState,
652 | OriginalPlan: originalPlan,
653 | OriginalUserIntent: originalUserIntent,
654 | OriginalAction: originalAction,
655 | AWSRegion: a.awsConfig.Region,
656 | ResourceMappings: resourceMappings,
657 | }
658 |
659 | return ctx
660 | }
661 |
662 | // ExecuteConfirmedPlanWithDryRun executes a confirmed execution plan with a specific dry run setting
663 | func (a *StateAwareAgent) ExecuteConfirmedPlanWithDryRun(ctx context.Context, decision *types.AgentDecision, progressChan chan<- *types.ExecutionUpdate, dryRun bool) (*types.PlanExecution, error) {
664 | if dryRun {
665 | a.Logger.Info("Dry run mode - simulating execution")
666 | a.Logger.Debug("About to call SimulatePlanExecution")
667 | result := a.SimulatePlanExecution(decision, progressChan)
668 | a.Logger.WithField("simulation_result", result.Status).Debug("Simulation completed")
669 | return result, nil
670 | }
671 |
672 | // Create execution plan
673 | execution := &types.PlanExecution{
674 | ID: uuid.New().String(),
675 | Name: fmt.Sprintf("Execute %s", decision.Action),
676 | Status: "running",
677 | StartedAt: time.Now(),
678 | Steps: []*types.ExecutionStep{},
679 | Changes: []*types.ChangeDetection{},
680 | Errors: []string{},
681 | }
682 |
683 | // Send initial progress update
684 | if progressChan != nil {
685 | progressChan <- &types.ExecutionUpdate{
686 | Type: "execution_started",
687 | ExecutionID: execution.ID,
688 | Message: "Starting plan execution",
689 | Timestamp: time.Now(),
690 | }
691 | }
692 |
693 | // Execute each step in the plan (simple execution without step-level recovery)
694 | for i, planStep := range decision.ExecutionPlan {
695 | // Send step started update
696 | if progressChan != nil {
697 | progressChan <- &types.ExecutionUpdate{
698 | Type: "step_started",
699 | ExecutionID: execution.ID,
700 | StepID: planStep.ID,
701 | Message: fmt.Sprintf("Starting step %d/%d: %s", i+1, len(decision.ExecutionPlan), planStep.Name),
702 | Timestamp: time.Now(),
703 | }
704 | }
705 |
706 | // Execute the step without recovery (simple execution)
707 | step, err := a.executeExecutionStep(planStep, execution, progressChan)
708 | if err != nil {
709 | execution.Status = "failed"
710 | execution.Errors = append(execution.Errors, fmt.Sprintf("Step %s failed: %v", planStep.ID, err))
711 |
712 | if progressChan != nil {
713 | progressChan <- &types.ExecutionUpdate{
714 | Type: "step_failed_final",
715 | ExecutionID: execution.ID,
716 | StepID: planStep.ID,
717 | Message: fmt.Sprintf("Step failed: %v", err),
718 | Error: err.Error(),
719 | Timestamp: time.Now(),
720 | }
721 | }
722 | break
723 | }
724 |
725 | execution.Steps = append(execution.Steps, step)
726 |
727 | // 🔥 CRITICAL: Save state after each successful step
728 | // This ensures that if later steps fail, we don't lose track of successfully created resources
729 | a.Logger.WithField("step_id", planStep.ID).Info("Attempting to persist state after successful step")
730 |
731 | if err := a.persistCurrentState(); err != nil {
732 | a.Logger.WithError(err).WithField("step_id", planStep.ID).Error("CRITICAL: Failed to persist state after successful step - this may cause state inconsistency")
733 | // Don't fail the execution for state persistence issues, but make it very visible
734 | } else {
735 | a.Logger.WithField("step_id", planStep.ID).Info("Successfully persisted state after step completion")
736 | }
737 |
738 | // Send step completed update
739 | if progressChan != nil {
740 | progressChan <- &types.ExecutionUpdate{
741 | Type: "step_completed",
742 | ExecutionID: execution.ID,
743 | StepID: planStep.ID,
744 | Message: fmt.Sprintf("Completed step %d/%d: %s", i+1, len(decision.ExecutionPlan), planStep.Name),
745 | Timestamp: time.Now(),
746 | }
747 | }
748 | }
749 |
750 | // Complete execution
751 | now := time.Now()
752 | execution.CompletedAt = &now
753 | if execution.Status != "failed" {
754 | execution.Status = "completed"
755 | }
756 |
757 | // Update decision record
758 | decision.ExecutedAt = &now
759 | if execution.Status == "failed" {
760 | decision.Result = "failed"
761 | decision.Error = strings.Join(execution.Errors, "; ")
762 | } else {
763 | decision.Result = "success"
764 | }
765 |
766 | // Send final progress update
767 | if progressChan != nil {
768 | progressChan <- &types.ExecutionUpdate{
769 | Type: "execution_completed",
770 | ExecutionID: execution.ID,
771 | Message: fmt.Sprintf("Plan execution %s", execution.Status),
772 | Timestamp: time.Now(),
773 | }
774 | }
775 |
776 | a.Logger.WithFields(map[string]interface{}{
777 | "execution_id": execution.ID,
778 | "status": execution.Status,
779 | "steps": len(execution.Steps),
780 | }).Info("Plan execution completed")
781 |
782 | return execution, nil
783 | }
784 |
785 | // SimulatePlanExecution simulates plan execution for dry run mode (exported version)
786 | func (a *StateAwareAgent) SimulatePlanExecution(decision *types.AgentDecision, progressChan chan<- *types.ExecutionUpdate) *types.PlanExecution {
787 | a.Logger.WithField("plan_steps", len(decision.ExecutionPlan)).Debug("Starting SimulatePlanExecution")
788 |
789 | now := time.Now()
790 | execution := &types.PlanExecution{
791 | ID: uuid.New().String(),
792 | Name: fmt.Sprintf("Simulate %s", decision.Action),
793 | Status: "running",
794 | StartedAt: now,
795 | Steps: []*types.ExecutionStep{},
796 | Changes: []*types.ChangeDetection{},
797 | Errors: []string{},
798 | }
799 |
800 | a.Logger.WithField("execution_id", execution.ID).Debug("Created execution plan")
801 |
802 | // Send initial update
803 | if progressChan != nil {
804 | a.Logger.Debug("Sending initial progress update")
805 | select {
806 | case progressChan <- &types.ExecutionUpdate{
807 | Type: "execution_started",
808 | ExecutionID: execution.ID,
809 | Message: "Starting plan simulation (dry run)",
810 | Timestamp: time.Now(),
811 | }:
812 | a.Logger.Debug("Initial progress update sent successfully")
813 | case <-time.After(time.Second * 5):
814 | a.Logger.Error("Timeout sending initial progress update - channel might be blocked")
815 | }
816 | } else {
817 | a.Logger.Debug("Progress channel is nil - skipping initial update")
818 | }
819 |
820 | a.Logger.WithField("steps_to_simulate", len(decision.ExecutionPlan)).Debug("Starting step simulation loop")
821 |
822 | // Simulate each step
823 | for i, planStep := range decision.ExecutionPlan {
824 | a.Logger.WithFields(map[string]interface{}{
825 | "step_number": i + 1,
826 | "step_id": planStep.ID,
827 | "step_name": planStep.Name,
828 | }).Debug("Simulating step")
829 |
830 | // Send step started update
831 | if progressChan != nil {
832 | select {
833 | case progressChan <- &types.ExecutionUpdate{
834 | Type: "step_started",
835 | ExecutionID: execution.ID,
836 | StepID: planStep.ID,
837 | Message: fmt.Sprintf("Simulating step %d/%d: %s", i+1, len(decision.ExecutionPlan), planStep.Name),
838 | Timestamp: time.Now(),
839 | }:
840 | a.Logger.Debug("Step started update sent")
841 | case <-time.After(time.Second * 2):
842 | a.Logger.Warn("Timeout sending step started update")
843 | }
844 | }
845 |
846 | // Simulate step execution with delay
847 | a.Logger.Debug("Sleeping for step simulation delay")
848 | stepDelayDuration := time.Millisecond * time.Duration(a.config.StepDelayMS)
849 | time.Sleep(stepDelayDuration)
850 |
851 | stepStart := time.Now()
852 | stepEnd := stepStart.Add(stepDelayDuration)
853 |
854 | step := &types.ExecutionStep{
855 | ID: planStep.ID,
856 | Name: planStep.Name,
857 | Status: "completed",
858 | Resource: planStep.ResourceID,
859 | Action: planStep.Action,
860 | StartedAt: &stepStart,
861 | CompletedAt: &stepEnd,
862 | Duration: stepDelayDuration,
863 | Output: map[string]interface{}{"simulated": true, "message": "Dry run - no actual changes made"},
864 | }
865 |
866 | execution.Steps = append(execution.Steps, step)
867 | a.Logger.WithField("steps_completed", len(execution.Steps)).Debug("Added step to execution")
868 |
869 | // Send step completed update
870 | if progressChan != nil {
871 | select {
872 | case progressChan <- &types.ExecutionUpdate{
873 | Type: "step_completed",
874 | ExecutionID: execution.ID,
875 | StepID: planStep.ID,
876 | Message: fmt.Sprintf("Simulated step %d/%d: %s", i+1, len(decision.ExecutionPlan), planStep.Name),
877 | Timestamp: time.Now(),
878 | }:
879 | a.Logger.Debug("Step completed update sent")
880 | case <-time.After(time.Second * 2):
881 | a.Logger.Warn("Timeout sending step completed update")
882 | }
883 | }
884 | }
885 |
886 | a.Logger.Debug("Completed all step simulations, finalizing execution")
887 |
888 | // Complete simulation
889 | completion := time.Now()
890 | execution.CompletedAt = &completion
891 | execution.Status = "completed"
892 |
893 | // Send final update
894 | if progressChan != nil {
895 | select {
896 | case progressChan <- &types.ExecutionUpdate{
897 | Type: "execution_completed",
898 | ExecutionID: execution.ID,
899 | Message: "Plan simulation completed (dry run)",
900 | Timestamp: time.Now(),
901 | }:
902 | a.Logger.Debug("Final progress update sent")
903 | case <-time.After(time.Second * 2):
904 | a.Logger.Warn("Timeout sending final progress update")
905 | }
906 | }
907 |
908 | a.Logger.WithFields(map[string]interface{}{
909 | "execution_id": execution.ID,
910 | "status": execution.Status,
911 | "steps": len(execution.Steps),
912 | }).Info("Plan simulation completed")
913 |
914 | return execution
915 | }
916 |
917 | // executeExecutionStep executes a single step in the execution plan
918 | func (a *StateAwareAgent) executeExecutionStep(planStep *types.ExecutionPlanStep, execution *types.PlanExecution, progressChan chan<- *types.ExecutionUpdate) (*types.ExecutionStep, error) {
919 | startTime := time.Now()
920 |
921 | step := &types.ExecutionStep{
922 | ID: planStep.ID,
923 | Name: planStep.Name,
924 | Status: "running",
925 | Resource: planStep.ResourceID,
926 | Action: planStep.Action,
927 | StartedAt: &startTime,
928 | }
929 |
930 | // Send progress update for step details
931 | if progressChan != nil {
932 | progressChan <- &types.ExecutionUpdate{
933 | Type: "step_progress",
934 | ExecutionID: execution.ID,
935 | StepID: planStep.ID,
936 | Message: fmt.Sprintf("Executing: %s", planStep.Description),
937 | Timestamp: time.Now(),
938 | }
939 | }
940 |
941 | // Execute based on action type
942 | var result map[string]interface{}
943 | var err error
944 |
945 | switch planStep.Action {
946 | case "create":
947 | result, err = a.executeCreateAction(planStep, progressChan, execution.ID)
948 | case "query":
949 | // Query action - executes MCP tools for data retrieval (unified with create)
950 | result, err = a.executeQueryAction(planStep, progressChan, execution.ID)
951 | // case "update":
952 | // result, err = a.executeUpdateAction(ctx, planStep, progressChan, execution.ID)
953 | // case "delete":
954 | // result, err = a.executeDeleteAction(planStep, progressChan, execution.ID)
955 | // case "validate":
956 | // result, err = a.executeValidateAction(planStep, progressChan, execution.ID)
957 | default:
958 | err = fmt.Errorf("unknown action type: %s", planStep.Action)
959 | }
960 |
961 | // Complete the step
962 | endTime := time.Now()
963 | step.CompletedAt = &endTime
964 | step.Duration = endTime.Sub(startTime)
965 |
966 | if err != nil {
967 | step.Status = "failed"
968 | step.Error = err.Error()
969 | } else {
970 | step.Status = "completed"
971 | step.Output = result
972 | }
973 |
974 | return step, err
975 | }
976 |
977 | // executeCreateAction handles resource creation using native MCP tool calls
978 | func (a *StateAwareAgent) executeCreateAction(planStep *types.ExecutionPlanStep, progressChan chan<- *types.ExecutionUpdate, executionID string) (map[string]interface{}, error) {
979 | // Send progress update
980 | if progressChan != nil {
981 | progressChan <- &types.ExecutionUpdate{
982 | Type: "step_progress",
983 | ExecutionID: executionID,
984 | StepID: planStep.ID,
985 | Message: fmt.Sprintf("Creating %s resource: %s", planStep.ResourceID, planStep.Name),
986 | Timestamp: time.Now(),
987 | }
988 | }
989 |
990 | // Use native MCP tool call approach
991 | return a.executeNativeMCPTool(planStep, progressChan, executionID)
992 | }
993 |
994 | // executeQueryAction handles data retrieval/query operations using native MCP tool calls
995 | func (a *StateAwareAgent) executeQueryAction(planStep *types.ExecutionPlanStep, progressChan chan<- *types.ExecutionUpdate, executionID string) (map[string]interface{}, error) {
996 | // Send progress update
997 | if progressChan != nil {
998 | progressChan <- &types.ExecutionUpdate{
999 | Type: "step_progress",
1000 | ExecutionID: executionID,
1001 | StepID: planStep.ID,
1002 | Message: fmt.Sprintf("Querying resource: %s", planStep.Name),
1003 | Timestamp: time.Now(),
1004 | }
1005 | }
1006 |
1007 | // Execute the MCP tool using the same path as create
1008 | return a.executeNativeMCPTool(planStep, progressChan, executionID)
1009 | }
1010 |
1011 | // executeNativeMCPTool executes MCP tools directly with AI-provided parameters
1012 | func (a *StateAwareAgent) executeNativeMCPTool(planStep *types.ExecutionPlanStep, _ chan<- *types.ExecutionUpdate, _ string) (map[string]interface{}, error) {
1013 | toolName := planStep.MCPTool
1014 |
1015 | if a.config.EnableDebug {
1016 | a.Logger.WithFields(map[string]interface{}{
1017 | "tool_name": toolName,
1018 | "step_id": planStep.ID,
1019 | "tool_parameters": planStep.ToolParameters,
1020 | }).Info("Executing native MCP tool call")
1021 | }
1022 |
1023 | // Ensure MCP capabilities are discovered
1024 | if err := a.ensureMCPCapabilities(); err != nil {
1025 | return nil, fmt.Errorf("failed to ensure MCP capabilities: %w", err)
1026 | }
1027 |
1028 | // Validate tool exists in discovered capabilities
1029 | a.capabilityMutex.RLock()
1030 | toolInfo, exists := a.mcpTools[toolName]
1031 | availableTools := make([]string, 0, len(a.mcpTools))
1032 | for tool := range a.mcpTools {
1033 | availableTools = append(availableTools, tool)
1034 | }
1035 | a.capabilityMutex.RUnlock()
1036 |
1037 | if !exists {
1038 | a.Logger.WithFields(map[string]interface{}{
1039 | "requested_tool": toolName,
1040 | "available_tools": availableTools,
1041 | "tools_count": len(availableTools),
1042 | }).Error("MCP tool not found - debugging tool discovery issue")
1043 | return nil, fmt.Errorf("MCP tool %s not found in discovered capabilities. Available tools: %v", toolName, availableTools)
1044 | }
1045 |
1046 | // Prepare tool arguments - start with AI-provided parameters
1047 | arguments := make(map[string]interface{})
1048 |
1049 | for key, value := range planStep.ToolParameters {
1050 | if strValue, ok := value.(string); ok {
1051 | if strings.Contains(strValue, "{{") && strings.Contains(strValue, "}}") {
1052 | if strings.Count(strValue, "{{") > 1 && strings.Contains(strValue, "},{{") {
1053 | // Handles comma-separated: "{{ref1}},{{ref2}},{{ref3}}"
1054 | parts := strings.Split(strValue, ",")
1055 | resolvedParts := make([]string, 0, len(parts))
1056 |
1057 | for _, part := range parts {
1058 | part = strings.TrimSpace(part)
1059 | if strings.Contains(part, "{{") && strings.Contains(part, "}}") {
1060 | resolvedValue, err := a.resolveDependencyReference(part)
1061 | if err != nil {
1062 | return nil, fmt.Errorf("failed to resolve dependency reference %s in comma-separated list for parameter %s: %w", part, key, err)
1063 | }
1064 | resolvedParts = append(resolvedParts, resolvedValue)
1065 | } else {
1066 | resolvedParts = append(resolvedParts, part)
1067 | }
1068 | }
1069 |
1070 | // Join resolved values back with comma
1071 | arguments[key] = strings.Join(resolvedParts, ",")
1072 |
1073 | if a.config.EnableDebug {
1074 | a.Logger.WithFields(map[string]interface{}{
1075 | "key": key,
1076 | "original_value": strValue,
1077 | "resolved_value": arguments[key],
1078 | "parts_resolved": len(resolvedParts),
1079 | }).Info("Successfully resolved comma-separated dependency references")
1080 | }
1081 | } else {
1082 | // Handles single reference: "{{step-id.field}}"
1083 | resolvedValue, err := a.resolveDependencyReference(strValue)
1084 | if err != nil {
1085 | return nil, fmt.Errorf("failed to resolve dependency reference %s for parameter %s: %w", strValue, key, err)
1086 | }
1087 |
1088 | // Check if the resolved value is a JSON array string
1089 | if strings.HasPrefix(resolvedValue, "[") && strings.HasSuffix(resolvedValue, "]") {
1090 | var arrayValue []interface{}
1091 | if err := json.Unmarshal([]byte(resolvedValue), &arrayValue); err == nil {
1092 | // Successfully parsed as JSON array - use it as array
1093 | arguments[key] = arrayValue
1094 |
1095 | if a.config.EnableDebug {
1096 | a.Logger.WithFields(map[string]interface{}{
1097 | "key": key,
1098 | "original_value": strValue,
1099 | "resolved_type": "array",
1100 | "array_length": len(arrayValue),
1101 | }).Info("Successfully resolved dependency reference as JSON array")
1102 | }
1103 | } else {
1104 | // Failed to parse - use as string
1105 | arguments[key] = resolvedValue
1106 |
1107 | if a.config.EnableDebug {
1108 | a.Logger.WithFields(map[string]interface{}{
1109 | "key": key,
1110 | "original_value": strValue,
1111 | "resolved_value": resolvedValue,
1112 | }).Info("Successfully resolved dependency reference as string")
1113 | }
1114 | }
1115 | } else {
1116 | // Not a JSON array - use as string
1117 | arguments[key] = resolvedValue
1118 |
1119 | if a.config.EnableDebug {
1120 | a.Logger.WithFields(map[string]interface{}{
1121 | "key": key,
1122 | "original_value": strValue,
1123 | "resolved_value": resolvedValue,
1124 | }).Info("Successfully resolved dependency reference")
1125 | }
1126 | }
1127 | }
1128 | } else {
1129 | arguments[key] = value
1130 | }
1131 | } else if arrayValue, ok := value.([]interface{}); ok {
1132 | // Handles array format: ["{{ref1}}", "{{ref2}}"]
1133 | resolvedArray := make([]interface{}, len(arrayValue))
1134 | for i, item := range arrayValue {
1135 | if strItem, ok := item.(string); ok && strings.Contains(strItem, "{{") && strings.Contains(strItem, "}}") {
1136 | resolvedValue, err := a.resolveDependencyReference(strItem)
1137 | if err != nil {
1138 | return nil, fmt.Errorf("failed to resolve dependency reference %s in array parameter %s[%d]: %w", strItem, key, i, err)
1139 | }
1140 |
1141 | resolvedArray[i] = resolvedValue
1142 | } else {
1143 | resolvedArray[i] = item
1144 | }
1145 | }
1146 | arguments[key] = resolvedArray
1147 | } else {
1148 | arguments[key] = value
1149 | }
1150 | }
1151 |
1152 | // Fill in missing required parameters with intelligent defaults
1153 | // if err := a.addMissingRequiredParameters(toolName, arguments, toolInfo); err != nil {
1154 | // return nil, fmt.Errorf("failed to add required parameters for tool %s: %w", toolName, err)
1155 | // }
1156 |
1157 | // Validate arguments before MCP call
1158 | if err := a.validateNativeMCPArguments(toolName, arguments, toolInfo); err != nil {
1159 | return nil, fmt.Errorf("invalid arguments for MCP tool %s: %w", toolName, err)
1160 | }
1161 |
1162 | // Call the actual MCP tool
1163 | result, err := a.callMCPTool(toolName, arguments)
1164 | if err != nil {
1165 | return nil, fmt.Errorf("MCP tool call failed: %w", err)
1166 | }
1167 |
1168 | // Process arrays BEFORE extraction so extraction sees concatenated values
1169 | processedResult := a.processArraysInMCPResponse(result)
1170 |
1171 | // Extract actual resource ID from MCP response (using processed result)
1172 | resourceID, err := a.extractResourceIDFromResponse(processedResult, toolName, planStep.ID)
1173 | if err != nil {
1174 | return nil, fmt.Errorf("failed to extract resource ID from MCP response for tool %s: %w", toolName, err)
1175 | }
1176 |
1177 | // Update the plan step with the actual resource ID so it gets stored correctly
1178 | planStep.ResourceID = resourceID
1179 |
1180 | // Store the mapping of plan step ID to actual resource ID and all array field mappings
1181 | a.storeResourceMapping(planStep.ID, resourceID, processedResult)
1182 |
1183 | // Wait for resource to be ready if it has dependencies
1184 | if err := a.waitForResourceReady(toolName, resourceID); err != nil {
1185 | a.Logger.WithError(err).WithFields(map[string]interface{}{
1186 | "step_id": planStep.ID,
1187 | "tool_name": toolName,
1188 | "resource_id": resourceID,
1189 | }).Error("Failed to wait for resource to be ready")
1190 | return nil, fmt.Errorf("resource %s not ready: %w", resourceID, err)
1191 | }
1192 |
1193 | // Update state manager with the new resource (use processed result)
1194 | if err := a.updateStateFromMCPResult(planStep, processedResult); err != nil {
1195 | a.Logger.WithError(err).WithFields(map[string]interface{}{
1196 | "step_id": planStep.ID,
1197 | "tool_name": toolName,
1198 | "resource_id": resourceID,
1199 | "result": processedResult,
1200 | }).Error("CRITICAL: Failed to update state after resource creation - this may cause state inconsistency")
1201 |
1202 | // Still continue execution but ensure this is visible
1203 | return nil, fmt.Errorf("failed to update state after creating resource %s: %w", resourceID, err)
1204 | }
1205 |
1206 | // Create result map for return
1207 | resultMap := map[string]interface{}{
1208 | "resource_id": resourceID,
1209 | "plan_step_id": planStep.ID,
1210 | "mcp_tool": toolName,
1211 | "mcp_response": processedResult, // Use processed result with concatenated arrays
1212 | }
1213 |
1214 | return resultMap, nil
1215 | }
1216 |
1217 | // // executeUpdateAction handles resource updates using real MCP tools
1218 | // func (a *StateAwareAgent) executeUpdateAction(_ context.Context, planStep *types.ExecutionPlanStep, progressChan chan<- *types.ExecutionUpdate, executionID string) (map[string]interface{}, error) {
1219 | // // Send progress update
1220 | // if progressChan != nil {
1221 | // progressChan <- &types.ExecutionUpdate{
1222 | // Type: "step_progress",
1223 | // ExecutionID: executionID,
1224 | // StepID: planStep.ID,
1225 | // Message: fmt.Sprintf("Updating %s resource: %s", planStep.ResourceID, planStep.Name),
1226 | // Timestamp: time.Now(),
1227 | // }
1228 | // }
1229 |
1230 | // // For update actions, we mainly just simulate for now since the focus is on create operations
1231 | // // The native MCP approach will be extended to update/delete actions in future iterations
1232 | // a.Logger.WithField("step_id", planStep.ID).Info("Simulating update action as focus is on create operations")
1233 | // time.Sleep(time.Second * 1)
1234 | // return map[string]interface{}{
1235 | // "resource_id": planStep.ResourceID,
1236 | // "status": "updated",
1237 | // "message": fmt.Sprintf("%s updated successfully (simulated)", planStep.Name),
1238 | // "changes": planStep.Parameters,
1239 | // "simulated": true,
1240 | // }, nil
1241 | // }
1242 |
1243 | // // executeDeleteAction handles resource deletion
1244 | // func (a *StateAwareAgent) executeDeleteAction(planStep *types.ExecutionPlanStep, progressChan chan<- *types.ExecutionUpdate, executionID string) (map[string]interface{}, error) {
1245 | // // Send progress update
1246 | // if progressChan != nil {
1247 | // progressChan <- &types.ExecutionUpdate{
1248 | // Type: "step_progress",
1249 | // ExecutionID: executionID,
1250 | // StepID: planStep.ID,
1251 | // Message: fmt.Sprintf("Deleting %s resource: %s", planStep.ResourceID, planStep.Name),
1252 | // Timestamp: time.Now(),
1253 | // }
1254 | // }
1255 |
1256 | // // Simulate resource deletion
1257 | // time.Sleep(time.Second * 1)
1258 |
1259 | // return map[string]interface{}{
1260 | // "resource_id": planStep.ResourceID,
1261 | // "status": "deleted",
1262 | // "message": fmt.Sprintf("%s deleted successfully", planStep.Name),
1263 | // }, nil
1264 | // }
1265 |
1266 | // // executeValidateAction handles validation steps using real MCP tools where possible
1267 | // func (a *StateAwareAgent) executeValidateAction(planStep *types.ExecutionPlanStep, progressChan chan<- *types.ExecutionUpdate, executionID string) (map[string]interface{}, error) {
1268 | // // Send progress update
1269 | // if progressChan != nil {
1270 | // progressChan <- &types.ExecutionUpdate{
1271 | // Type: "step_progress",
1272 | // ExecutionID: executionID,
1273 | // StepID: planStep.ID,
1274 | // Message: fmt.Sprintf("Validating %s: %s", planStep.ResourceID, planStep.Name),
1275 | // Timestamp: time.Now(),
1276 | // }
1277 | // }
1278 |
1279 | // // For validation actions, we mainly just simulate for now since the focus is on create operations
1280 | // // The native MCP approach will be extended to validation actions in future iterations
1281 | // a.Logger.WithField("step_id", planStep.ID).Info("Simulating validation action as focus is on create operations")
1282 | // time.Sleep(time.Millisecond * 500)
1283 | // return map[string]interface{}{
1284 | // "resource_id": planStep.ResourceID,
1285 | // "status": "validated",
1286 | // "message": fmt.Sprintf("%s validation completed (simulated)", planStep.Name),
1287 | // "checks": []string{"basic_validation"},
1288 | // }, nil
1289 | // }
1290 |
1291 | // updateStateFromMCPResult updates the state manager with results from MCP operations
1292 | func (a *StateAwareAgent) updateStateFromMCPResult(planStep *types.ExecutionPlanStep, result map[string]interface{}) error {
1293 | a.Logger.WithFields(map[string]interface{}{
1294 | "step_id": planStep.ID,
1295 | "step_name": planStep.Name,
1296 | "resource_id": planStep.ResourceID,
1297 | "mcp_response": result,
1298 | }).Info("Starting state update from MCP result")
1299 |
1300 | // Note: result is already processed (arrays concatenated) from executeNativeMCPTool
1301 | // Create a simple properties map from MCP result
1302 | resultData := map[string]interface{}{
1303 | "mcp_response": result,
1304 | "status": "created_via_mcp",
1305 | }
1306 |
1307 | // Extract resource type
1308 | resourceType := a.extractResourceTypeFromStep(planStep)
1309 |
1310 | // Create a resource state entry
1311 | resourceState := &types.ResourceState{
1312 | ID: planStep.ResourceID,
1313 | Name: planStep.Name,
1314 | Description: planStep.Description,
1315 | Type: resourceType,
1316 | Status: "created",
1317 | Properties: resultData,
1318 | Dependencies: planStep.DependsOn,
1319 | CreatedAt: time.Now(),
1320 | UpdatedAt: time.Now(),
1321 | }
1322 |
1323 | a.Logger.WithFields(map[string]interface{}{
1324 | "step_id": planStep.ID,
1325 | "resource_state_id": resourceState.ID,
1326 | "resource_type": resourceState.Type,
1327 | "dependencies": resourceState.Dependencies,
1328 | }).Info("Calling AddResourceToState for main AWS resource")
1329 |
1330 | // Add to state manager via MCP server
1331 | if err := a.AddResourceToState(resourceState); err != nil {
1332 | a.Logger.WithError(err).WithFields(map[string]interface{}{
1333 | "step_id": planStep.ID,
1334 | "resource_state_id": resourceState.ID,
1335 | "resource_type": resourceState.Type,
1336 | }).Error("Failed to add resource to state via MCP server")
1337 | return fmt.Errorf("failed to add resource %s to state: %w", resourceState.ID, err)
1338 | }
1339 |
1340 | a.Logger.WithFields(map[string]interface{}{
1341 | "step_id": planStep.ID,
1342 | "resource_state_id": resourceState.ID,
1343 | "resource_type": resourceState.Type,
1344 | }).Info("Successfully added main AWS resource to state")
1345 |
1346 | // Also store the resource with the step ID as the key for dependency resolution
1347 | // This ensures that {{step-create-xxx.resourceId}} references can be resolved
1348 | if planStep.ID != planStep.ResourceID {
1349 |
1350 | stepResourceState := &types.ResourceState{
1351 | ID: planStep.ID, // Use step ID as the key
1352 | Name: planStep.Name,
1353 | Description: planStep.Description + " (Step Reference)",
1354 | Type: "step_reference",
1355 | Status: "created",
1356 | Properties: resultData,
1357 | Dependencies: planStep.DependsOn,
1358 | CreatedAt: time.Now(),
1359 | UpdatedAt: time.Now(),
1360 | }
1361 |
1362 | if err := a.AddResourceToState(stepResourceState); err != nil {
1363 | if a.config.EnableDebug {
1364 | a.Logger.WithError(err).WithFields(map[string]interface{}{
1365 | "step_id": planStep.ID,
1366 | "step_resource_id": stepResourceState.ID,
1367 | }).Warn("Failed to add step-based resource to state - dependency resolution may be affected")
1368 | }
1369 | // Don't fail the whole operation for this, just log the warning
1370 | } else {
1371 | a.Logger.WithFields(map[string]interface{}{
1372 | "step_id": planStep.ID,
1373 | "step_resource_id": stepResourceState.ID,
1374 | "type": "step_reference",
1375 | }).Info("Successfully added step reference to state for dependency resolution")
1376 | }
1377 | } else {
1378 | a.Logger.WithFields(map[string]interface{}{
1379 | "step_id": planStep.ID,
1380 | "resource_id": planStep.ResourceID,
1381 | "reason": "step_id equals resource_id",
1382 | }).Info("Skipping step reference creation - not needed for dependency resolution")
1383 | }
1384 |
1385 | a.Logger.WithFields(map[string]interface{}{
1386 | "step_id": planStep.ID,
1387 | "main_resource_id": resourceState.ID,
1388 | "main_resource_type": resourceState.Type,
1389 | "step_reference_created": planStep.ID != planStep.ResourceID,
1390 | }).Info("Successfully completed state update from MCP result")
1391 |
1392 | return nil
1393 | }
1394 |
1395 | // Helper function to extract resource type from plan step
1396 | func (a *StateAwareAgent) extractResourceTypeFromStep(planStep *types.ExecutionPlanStep) string {
1397 | // First try the resource_type parameter
1398 | if rt, exists := planStep.Parameters["resource_type"]; exists {
1399 | if rtStr, ok := rt.(string); ok {
1400 | return rtStr
1401 | }
1402 | }
1403 |
1404 | // Try to infer from MCP tool name using pattern matcher
1405 | if planStep.MCPTool != "" {
1406 | resourceType := a.patternMatcher.IdentifyResourceTypeFromToolName(planStep.MCPTool)
1407 | if resourceType != "" && resourceType != "unknown" {
1408 | return resourceType
1409 | }
1410 | }
1411 |
1412 | // Try to infer from ResourceID field using pattern matcher
1413 | if planStep.ResourceID != "" {
1414 | // Use pattern matcher to identify resource type from ID
1415 | resourceType := a.patternMatcher.IdentifyResourceType(planStep)
1416 | if resourceType != "" && resourceType != "unknown" {
1417 | return resourceType
1418 | }
1419 | }
1420 |
1421 | // Try to infer from step name or description using pattern matcher
1422 | resourceType := a.patternMatcher.InferResourceTypeFromDescription(planStep.Name + " " + planStep.Description)
1423 | if resourceType != "" && resourceType != "unknown" {
1424 | return resourceType
1425 | }
1426 |
1427 | return ""
1428 | }
1429 |
1430 | // getAvailableToolsContext returns a formatted string of available tools for the AI to understand
1431 | func (a *StateAwareAgent) getAvailableToolsContext() (string, error) {
1432 | a.capabilityMutex.RLock()
1433 | toolsCount := len(a.mcpTools)
1434 | a.capabilityMutex.RUnlock()
1435 |
1436 | if toolsCount == 0 {
1437 | // Try to ensure capabilities are available
1438 | if err := a.ensureMCPCapabilities(); err != nil {
1439 | a.Logger.WithError(err).Error("Failed to ensure MCP capabilities in getAvailableToolsContext")
1440 | return "", fmt.Errorf("failed to ensure MCP capabilities: %w", err)
1441 | }
1442 |
1443 | // Re-check after ensuring capabilities
1444 | a.capabilityMutex.RLock()
1445 | toolsCount = len(a.mcpTools)
1446 | a.capabilityMutex.RUnlock()
1447 | }
1448 |
1449 | if toolsCount == 0 {
1450 | return "", fmt.Errorf("no MCP tools discovered - MCP server may not be properly initialized")
1451 | }
1452 |
1453 | // Generate dynamic MCP tools schema
1454 | mcpToolsSchema := a.generateMCPToolsSchema()
1455 |
1456 | // Load template with MCP tools placeholder
1457 | placeholders := map[string]string{
1458 | "MCP_TOOLS_SCHEMAS": mcpToolsSchema,
1459 | }
1460 |
1461 | // Use the new template-based approach
1462 | executionContext, err := a.loadTemplateWithPlaceholders("settings/templates/tools-execution-context-optimized.txt", placeholders)
1463 | if err != nil {
1464 | a.Logger.WithError(err).Error("Failed to load tools execution template with placeholders")
1465 | return "", fmt.Errorf("failed to load tools execution template: %w", err)
1466 | }
1467 |
1468 | return executionContext, nil
1469 | }
1470 |
1471 | // generateMCPToolsSchema generates the dynamic MCP tools schema section
1472 | func (a *StateAwareAgent) generateMCPToolsSchema() string {
1473 | a.capabilityMutex.RLock()
1474 | defer a.capabilityMutex.RUnlock()
1475 |
1476 | var context strings.Builder
1477 | context.WriteString("=== AVAILABLE MCP TOOLS WITH FULL SCHEMAS ===\n\n")
1478 | context.WriteString("You have direct access to these MCP tools. Use the exact tool names and parameter structures shown below.\n\n")
1479 |
1480 | // Get available categories from pattern matcher configuration
1481 | availableCategories := a.patternMatcher.GetAvailableCategories()
1482 |
1483 | // Initialize categories with empty slices
1484 | categories := make(map[string][]string)
1485 | for _, category := range availableCategories {
1486 | categories[category] = []string{}
1487 | }
1488 |
1489 | // Ensure "Other" category exists as fallback
1490 | if _, exists := categories["Other"]; !exists {
1491 | categories["Other"] = []string{}
1492 | }
1493 |
1494 | toolDetails := make(map[string]string)
1495 |
1496 | // Categorize tools using pattern matcher
1497 | for toolName, toolInfo := range a.mcpTools {
1498 | // Use pattern matcher to get category based on tool name and resource type patterns
1499 | category := a.patternMatcher.GetCategoryForTool(toolName)
1500 |
1501 | // Fallback to "Other" if category not found
1502 | if _, exists := categories[category]; !exists {
1503 | category = "Other"
1504 | }
1505 |
1506 | // Build detailed tool schema
1507 | var toolDetail strings.Builder
1508 | toolDetail.WriteString(fmt.Sprintf(" TOOL: %s\n", toolName))
1509 | toolDetail.WriteString(fmt.Sprintf(" Description: %s\n", toolInfo.Description))
1510 |
1511 | if toolInfo.InputSchema != nil {
1512 | if properties, ok := toolInfo.InputSchema["properties"].(map[string]interface{}); ok {
1513 | toolDetail.WriteString(" Parameters:\n")
1514 |
1515 | // Get required fields
1516 | requiredFields := make(map[string]bool)
1517 | if required, ok := toolInfo.InputSchema["required"].([]interface{}); ok {
1518 | for _, field := range required {
1519 | if fieldStr, ok := field.(string); ok {
1520 | requiredFields[fieldStr] = true
1521 | }
1522 | }
1523 | }
1524 |
1525 | for paramName, paramSchema := range properties {
1526 | if paramSchemaMap, ok := paramSchema.(map[string]interface{}); ok {
1527 | requiredMark := ""
1528 | if requiredFields[paramName] {
1529 | requiredMark = " (REQUIRED)"
1530 | }
1531 |
1532 | paramType := "string"
1533 | if pType, exists := paramSchemaMap["type"]; exists {
1534 | paramType = fmt.Sprintf("%v", pType)
1535 | }
1536 |
1537 | description := ""
1538 | if desc, exists := paramSchemaMap["description"]; exists {
1539 | description = fmt.Sprintf(" - %v", desc)
1540 | }
1541 |
1542 | toolDetail.WriteString(fmt.Sprintf(" - %s: %s%s%s\n", paramName, paramType, requiredMark, description))
1543 | }
1544 | }
1545 | }
1546 | }
1547 | toolDetail.WriteString("\n")
1548 |
1549 | categories[category] = append(categories[category], toolName)
1550 | toolDetails[toolName] = toolDetail.String()
1551 | }
1552 |
1553 | // Write categorized tools with full schemas
1554 | for category, tools := range categories {
1555 | if len(tools) > 0 {
1556 | context.WriteString(fmt.Sprintf("=== %s ===\n\n", category))
1557 | for _, toolName := range tools {
1558 | context.WriteString(toolDetails[toolName])
1559 | }
1560 | }
1561 | }
1562 |
1563 | return context.String()
1564 | }
1565 |
1566 | // persistCurrentState saves the current infrastructure state to persistent storage
1567 | // This ensures that successfully completed steps are not lost if later steps fail
1568 | func (a *StateAwareAgent) persistCurrentState() error {
1569 | a.Logger.Info("Starting state persistence via MCP server")
1570 |
1571 | // Use MCP server to save the current state
1572 | result, err := a.callMCPTool("save-state", map[string]interface{}{
1573 | "force": true, // Force save even if state hasn't changed much
1574 | })
1575 | if err != nil {
1576 | a.Logger.WithError(err).Error("Failed to call save-state MCP tool")
1577 | return fmt.Errorf("failed to save state via MCP: %w", err)
1578 | }
1579 |
1580 | a.Logger.WithField("result", result).Info("State persistence completed successfully via MCP server")
1581 | return nil
1582 | }
1583 |
1584 | // extractResourceIDFromResponse extracts the actual AWS resource ID from MCP response
1585 | // Note: result should be the processed result with concatenated arrays
1586 | func (a *StateAwareAgent) extractResourceIDFromResponse(result map[string]interface{}, toolName string, stepID string) (string, error) {
1587 | // Use configuration-driven extraction for primary resource ID
1588 | resourceType := a.patternMatcher.IdentifyResourceTypeFromToolName(toolName)
1589 | if resourceType == "" || resourceType == "unknown" {
1590 | return "", fmt.Errorf("could not identify resource type for tool %s", toolName)
1591 | }
1592 |
1593 | extractedID, err := a.idExtractor.ExtractResourceID(toolName, resourceType, nil, result)
1594 | if err != nil {
1595 | a.Logger.WithFields(map[string]interface{}{
1596 | "tool_name": toolName,
1597 | "resource_type": resourceType,
1598 | "error": err.Error(),
1599 | }).Error("Failed to extract resource ID using configuration-driven approach")
1600 | return "", fmt.Errorf("could not extract resource ID from MCP response for tool %s: %w", toolName, err)
1601 | }
1602 |
1603 | if extractedID == "" {
1604 | return "", fmt.Errorf("extracted empty resource ID for tool %s", toolName)
1605 | }
1606 |
1607 | if a.config.EnableDebug {
1608 | a.Logger.WithFields(map[string]interface{}{
1609 | "tool_name": toolName,
1610 | "resource_type": resourceType,
1611 | "resource_id": extractedID,
1612 | "step_id": stepID,
1613 | }).Info("Successfully extracted resource ID")
1614 | }
1615 |
1616 | return extractedID, nil
1617 | }
1618 |
1619 | // waitForResourceReady waits for AWS resources to be in a ready state before continuing
1620 | func (a *StateAwareAgent) waitForResourceReady(toolName, resourceID string) error {
1621 | if a.testMode {
1622 | return nil
1623 | }
1624 |
1625 | // Determine if this resource type needs waiting
1626 | needsWaiting := false
1627 | maxWaitTime := 5 * time.Minute
1628 | checkInterval := 15 * time.Second
1629 |
1630 | switch toolName {
1631 | case "create-nat-gateway":
1632 | needsWaiting = true
1633 | maxWaitTime = 5 * time.Minute // NAT gateways typically take 2-3 minutes
1634 | case "create-rds-db-instance", "create-database":
1635 | needsWaiting = true
1636 | maxWaitTime = 15 * time.Minute // RDS instances can take longer
1637 | case "create-internet-gateway", "create-vpc", "create-subnet":
1638 | // These are typically available immediately
1639 | needsWaiting = false
1640 | default:
1641 | // For other resources, don't wait
1642 | needsWaiting = false
1643 | }
1644 |
1645 | if !needsWaiting {
1646 | a.Logger.WithFields(map[string]interface{}{
1647 | "tool_name": toolName,
1648 | "resource_id": resourceID,
1649 | }).Debug("Resource type does not require waiting")
1650 | return nil
1651 | }
1652 |
1653 | a.Logger.WithFields(map[string]interface{}{
1654 | "tool_name": toolName,
1655 | "resource_id": resourceID,
1656 | "max_wait_time": maxWaitTime,
1657 | "check_interval": checkInterval,
1658 | }).Info("Waiting for resource to be ready")
1659 |
1660 | startTime := time.Now()
1661 | timeout := time.After(maxWaitTime)
1662 | ticker := time.NewTicker(checkInterval)
1663 | defer ticker.Stop()
1664 |
1665 | for {
1666 | select {
1667 | case <-timeout:
1668 | elapsed := time.Since(startTime)
1669 | return fmt.Errorf("timeout waiting for %s %s to be ready after %v", toolName, resourceID, elapsed)
1670 |
1671 | case <-ticker.C:
1672 | ready, err := a.checkResourceState(toolName, resourceID)
1673 | if err != nil {
1674 | a.Logger.WithError(err).WithFields(map[string]interface{}{
1675 | "tool_name": toolName,
1676 | "resource_id": resourceID,
1677 | }).Warn("Error checking resource state, will retry")
1678 | continue
1679 | }
1680 |
1681 | if ready {
1682 | elapsed := time.Since(startTime)
1683 | a.Logger.WithFields(map[string]interface{}{
1684 | "tool_name": toolName,
1685 | "resource_id": resourceID,
1686 | "elapsed": elapsed,
1687 | }).Info("Resource is ready")
1688 | return nil
1689 | }
1690 |
1691 | elapsed := time.Since(startTime)
1692 | a.Logger.WithFields(map[string]interface{}{
1693 | "tool_name": toolName,
1694 | "resource_id": resourceID,
1695 | "elapsed": elapsed,
1696 | }).Debug("Resource not ready yet, continuing to wait")
1697 | }
1698 | }
1699 | }
1700 |
1701 | // checkResourceState checks if a specific AWS resource is in a ready state
1702 | func (a *StateAwareAgent) checkResourceState(toolName, resourceID string) (bool, error) {
1703 | switch toolName {
1704 | case "create-nat-gateway":
1705 | return a.checkNATGatewayState(resourceID)
1706 | case "create-rds-db-instance", "create-database":
1707 | return a.checkRDSInstanceState(resourceID)
1708 | default:
1709 | // For unknown resource types, assume they're ready
1710 | return true, nil
1711 | }
1712 | }
1713 |
1714 | // checkNATGatewayState checks if a NAT gateway is available
1715 | func (a *StateAwareAgent) checkNATGatewayState(natGatewayID string) (bool, error) {
1716 | // Try to use MCP tool to describe the NAT gateway if available
1717 | result, err := a.callMCPTool("describe-nat-gateways", map[string]interface{}{
1718 | "natGatewayIds": []string{natGatewayID},
1719 | })
1720 | if err != nil {
1721 | // If describe tool is not available, use a simple time-based approach
1722 | a.Logger.WithFields(map[string]interface{}{
1723 | "nat_gateway_id": natGatewayID,
1724 | "error": err.Error(),
1725 | }).Warn("describe-nat-gateways tool not available, using time-based wait")
1726 |
1727 | // NAT gateways typically take 2-3 minutes to become available
1728 | // We'll wait a fixed amount of time and then assume it's ready
1729 | time.Sleep(30 * time.Second)
1730 | return true, nil
1731 | }
1732 |
1733 | // Parse the response to check the state
1734 | if natGateways, ok := result["natGateways"].([]interface{}); ok && len(natGateways) > 0 {
1735 | if natGateway, ok := natGateways[0].(map[string]interface{}); ok {
1736 | if state, ok := natGateway["state"].(string); ok {
1737 | a.Logger.WithFields(map[string]interface{}{
1738 | "nat_gateway_id": natGatewayID,
1739 | "state": state,
1740 | }).Debug("NAT gateway state check")
1741 |
1742 | return state == "available", nil
1743 | }
1744 | }
1745 | }
1746 |
1747 | return false, fmt.Errorf("could not determine NAT gateway state from response")
1748 | }
1749 |
1750 | // checkRDSInstanceState checks if an RDS instance is available
1751 | func (a *StateAwareAgent) checkRDSInstanceState(dbInstanceID string) (bool, error) {
1752 | // Try to use MCP tool to describe the RDS instance if available
1753 | result, err := a.callMCPTool("describe-db-instances", map[string]interface{}{
1754 | "dbInstanceIdentifier": dbInstanceID,
1755 | })
1756 | if err != nil {
1757 | // If describe tool is not available, use a simple time-based approach
1758 | a.Logger.WithFields(map[string]interface{}{
1759 | "db_instance_id": dbInstanceID,
1760 | "error": err.Error(),
1761 | }).Warn("describe-db-instances tool not available, using time-based wait")
1762 |
1763 | // RDS instances typically take 5-10 minutes to become available
1764 | // We'll wait a fixed amount of time and then assume it's ready
1765 | time.Sleep(60 * time.Second)
1766 | return true, nil
1767 | }
1768 |
1769 | // Parse the response to check the state
1770 | if dbInstances, ok := result["dbInstances"].([]interface{}); ok && len(dbInstances) > 0 {
1771 | if dbInstance, ok := dbInstances[0].(map[string]interface{}); ok {
1772 | if status, ok := dbInstance["dbInstanceStatus"].(string); ok {
1773 | a.Logger.WithFields(map[string]interface{}{
1774 | "db_instance_id": dbInstanceID,
1775 | "status": status,
1776 | }).Debug("RDS instance state check")
1777 |
1778 | return status == "available", nil
1779 | }
1780 | }
1781 | }
1782 |
1783 | return false, fmt.Errorf("could not determine RDS instance state from response")
1784 | }
1785 |
1786 | // processArraysInMCPResponse processes MCP response to concatenate array fields with _ delimiter
1787 | // This provides unified array handling where arrays are stored as "item1_item2_item3"
1788 | func (a *StateAwareAgent) processArraysInMCPResponse(result map[string]interface{}) map[string]interface{} {
1789 | processed := make(map[string]interface{})
1790 |
1791 | for key, value := range result {
1792 | // Check if value is an array of strings
1793 | if arrValue, ok := value.([]interface{}); ok && len(arrValue) > 0 {
1794 | // Check if array contains strings
1795 | stringArray := make([]string, 0, len(arrValue))
1796 | allStrings := true
1797 |
1798 | for _, item := range arrValue {
1799 | if strItem, ok := item.(string); ok {
1800 | stringArray = append(stringArray, strItem)
1801 | } else {
1802 | allStrings = false
1803 | break
1804 | }
1805 | }
1806 |
1807 | // If it's an array of strings, concatenate with _
1808 | if allStrings && len(stringArray) > 0 {
1809 | concatenated := strings.Join(stringArray, "_")
1810 |
1811 | // Store both concatenated version and original array
1812 | processed[key] = concatenated
1813 | processed[key+"_array"] = arrValue // Keep original for other processing
1814 |
1815 | continue
1816 | }
1817 | }
1818 |
1819 | // For non-string-arrays, keep as-is
1820 | processed[key] = value
1821 | }
1822 |
1823 | return processed
1824 | }
1825 |
1826 | // storeResourceMapping stores the mapping between plan step ID and actual AWS resource ID
1827 | // Also stores all array field mappings from the processed result for field-specific references
1828 | func (a *StateAwareAgent) storeResourceMapping(stepID, resourceID string, processedResult map[string]interface{}) {
1829 | a.mappingsMutex.Lock()
1830 | defer a.mappingsMutex.Unlock()
1831 |
1832 | // Store primary resource ID mapping
1833 | a.resourceMappings[stepID] = resourceID
1834 |
1835 | // Store all array field mappings for field-specific references (e.g., {{step-id.zones}})
1836 | for key, value := range processedResult {
1837 | // Skip the original array fields (ending with _array)
1838 | if strings.HasSuffix(key, "_array") {
1839 | continue
1840 | }
1841 |
1842 | // Store concatenated string values as step-id.fieldname mappings
1843 | if strValue, ok := value.(string); ok && strValue != "" {
1844 | // Check if this looks like a concatenated array (contains _)
1845 | // or if there's a corresponding _array field
1846 | if strings.Contains(strValue, "_") || processedResult[key+"_array"] != nil {
1847 | mappingKey := fmt.Sprintf("%s.%s", stepID, key)
1848 | a.resourceMappings[mappingKey] = strValue
1849 | }
1850 | }
1851 | }
1852 | }
1853 |
1854 | // StoreResourceMapping is a public wrapper for storeResourceMapping for external use
1855 | func (a *StateAwareAgent) StoreResourceMapping(stepID, resourceID string, processedResult map[string]interface{}) {
1856 | a.storeResourceMapping(stepID, resourceID, processedResult)
1857 | }
1858 |
```