This is page 99 of 104. 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
│ │ ├── simple-demo.svg
│ │ ├── 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_agent_extensions.go
│ │ ├── react_error_context.go
│ │ ├── react_recovery_engine.go
│ │ ├── react_recovery_types.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
│ └── 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
├── robots.txt
└── static
├── css
│ ├── main.c910004d.css
│ └── main.c910004d.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.f10cd903.chunk.js
├── 1595.f10cd903.chunk.js.LICENSE.txt
├── 1595.f10cd903.chunk.js.map
├── 1707.26c2b146.chunk.js
├── 1707.26c2b146.chunk.js.map
├── 2019.3e4e6398.chunk.js
├── 2019.3e4e6398.chunk.js.map
├── 2038.86d3ba27.chunk.js
├── 2038.86d3ba27.chunk.js.map
├── 2374.75cb7c60.chunk.js
├── 2374.75cb7c60.chunk.js.LICENSE.txt
├── 2374.75cb7c60.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
├── 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.02ce9149.chunk.js
├── 7069.02ce9149.chunk.js.map
├── 7513.37f12f0e.chunk.js
├── 7513.37f12f0e.chunk.js.map
├── 7550.0cfdabcf.chunk.js
├── 7550.0cfdabcf.chunk.js.map
├── 7681.ee495de8.chunk.js
├── 7681.ee495de8.chunk.js.LICENSE.txt
├── 7681.ee495de8.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.7fdeafe8.chunk.js
├── 8660.7fdeafe8.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.4cda12e2.js
├── main.4cda12e2.js.LICENSE.txt
└── main.4cda12e2.js.map
```
# Files
--------------------------------------------------------------------------------
/pkg/agent/mocks/mcp_server_mock.go:
--------------------------------------------------------------------------------
```go
1 | package mocks
2 |
3 | import (
4 | "context"
5 | "encoding/json"
6 | "fmt"
7 | "strings"
8 | "sync"
9 |
10 | "github.com/mark3labs/mcp-go/mcp"
11 | "github.com/versus-control/ai-infrastructure-agent/internal/logging"
12 | "github.com/versus-control/ai-infrastructure-agent/pkg/aws"
13 | "github.com/versus-control/ai-infrastructure-agent/pkg/interfaces"
14 | "github.com/versus-control/ai-infrastructure-agent/pkg/types"
15 | )
16 |
17 | // MockMCPServer implements a mock MCP server for testing
18 | type MockMCPServer struct {
19 | logger *logging.Logger
20 | tools map[string]interfaces.MCPTool
21 | resources map[string]*types.AWSResource
22 | stateManager *MockStateManager
23 | awsClient *MockAWSClient
24 | mutex sync.RWMutex
25 |
26 | // Response configuration
27 | simulateErrors map[string]error
28 | customResponses map[string]*mcp.CallToolResult
29 | }
30 |
31 | // NewMockMCPServer creates a new mock MCP server
32 | func NewMockMCPServer(logger *logging.Logger) *MockMCPServer {
33 | return &MockMCPServer{
34 | logger: logger,
35 | tools: make(map[string]interfaces.MCPTool),
36 | resources: make(map[string]*types.AWSResource),
37 | stateManager: NewMockStateManager(),
38 | awsClient: nil, // Will be set via SetAWSClient
39 | simulateErrors: make(map[string]error),
40 | customResponses: make(map[string]*mcp.CallToolResult),
41 | }
42 | }
43 |
44 | // NewMockMCPServerWithAWSClient creates a new mock MCP server with AWS client
45 | func NewMockMCPServerWithAWSClient(logger *logging.Logger, awsClient *MockAWSClient) *MockMCPServer {
46 | return &MockMCPServer{
47 | logger: logger,
48 | tools: make(map[string]interfaces.MCPTool),
49 | resources: make(map[string]*types.AWSResource),
50 | stateManager: NewMockStateManager(),
51 | awsClient: awsClient,
52 | simulateErrors: make(map[string]error),
53 | customResponses: make(map[string]*mcp.CallToolResult),
54 | }
55 | }
56 |
57 | // SetAWSClient sets the AWS client for the mock server
58 | func (m *MockMCPServer) SetAWSClient(awsClient *MockAWSClient) {
59 | m.mutex.Lock()
60 | defer m.mutex.Unlock()
61 | m.awsClient = awsClient
62 | }
63 |
64 | // Execute implements the MCPTool interface for the mock server itself
65 | func (m *MockMCPServer) Execute(ctx context.Context, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
66 | // This method allows the MockMCPServer to be used as an MCPTool
67 | // It delegates to CallTool with a default tool name if provided in arguments
68 | if toolName, ok := arguments["tool_name"].(string); ok {
69 | // Remove tool_name from arguments before calling the tool
70 | toolArgs := make(map[string]interface{})
71 | for k, v := range arguments {
72 | if k != "tool_name" {
73 | toolArgs[k] = v
74 | }
75 | }
76 | return m.CallTool(ctx, toolName, toolArgs)
77 | }
78 |
79 | return &mcp.CallToolResult{
80 | IsError: true,
81 | Content: []mcp.Content{
82 | &mcp.TextContent{
83 | Type: "text",
84 | Text: "MockMCPServer Execute requires 'tool_name' parameter",
85 | },
86 | },
87 | }, nil
88 | }
89 |
90 | // Name implements MCPTool interface
91 | func (m *MockMCPServer) Name() string {
92 | return "mock-mcp-server"
93 | }
94 |
95 | // Description implements MCPTool interface
96 | func (m *MockMCPServer) Description() string {
97 | return "Mock MCP server for testing"
98 | }
99 |
100 | // Category implements MCPTool interface
101 | func (m *MockMCPServer) Category() string {
102 | return "testing"
103 | }
104 |
105 | // GetInputSchema implements MCPTool interface
106 | func (m *MockMCPServer) GetInputSchema() map[string]interface{} {
107 | return map[string]interface{}{
108 | "type": "object",
109 | "properties": map[string]interface{}{
110 | "tool_name": map[string]interface{}{
111 | "type": "string",
112 | "description": "Name of the tool to execute",
113 | },
114 | },
115 | "required": []string{"tool_name"},
116 | }
117 | }
118 |
119 | // GetOutputSchema implements MCPTool interface
120 | func (m *MockMCPServer) GetOutputSchema() map[string]interface{} {
121 | return map[string]interface{}{
122 | "type": "object",
123 | "description": "Tool execution result",
124 | }
125 | }
126 |
127 | // GetExamples implements MCPTool interface
128 | func (m *MockMCPServer) GetExamples() []interfaces.ToolExample {
129 | return []interfaces.ToolExample{
130 | {
131 | Description: "Execute a mock tool",
132 | Arguments: map[string]interface{}{
133 | "tool_name": "create-vpc",
134 | "name": "test-vpc",
135 | "cidrBlock": "10.0.0.0/16",
136 | },
137 | Expected: "VPC creation result",
138 | },
139 | }
140 | }
141 |
142 | // ValidateArguments implements MCPTool interface
143 | func (m *MockMCPServer) ValidateArguments(arguments map[string]interface{}) error {
144 | if _, ok := arguments["tool_name"]; !ok {
145 | return fmt.Errorf("tool_name is required")
146 | }
147 | return nil
148 | }
149 |
150 | // RegisterTool registers a tool with the mock server
151 | func (m *MockMCPServer) RegisterTool(tool interfaces.MCPTool) error {
152 | m.mutex.Lock()
153 | defer m.mutex.Unlock()
154 |
155 | m.tools[tool.Name()] = tool
156 | m.logger.Info("Registered mock tool", "tool", tool.Name())
157 | return nil
158 | }
159 |
160 | // CallTool simulates calling an MCP tool
161 | func (m *MockMCPServer) CallTool(ctx context.Context, toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
162 | m.mutex.RLock()
163 | defer m.mutex.RUnlock()
164 |
165 | // Check for simulated errors
166 | if err, exists := m.simulateErrors[toolName]; exists {
167 | return nil, err
168 | }
169 |
170 | // Check for custom responses
171 | if response, exists := m.customResponses[toolName]; exists {
172 | return response, nil
173 | }
174 |
175 | // Check if tool exists
176 | tool, exists := m.tools[toolName]
177 | if !exists {
178 | // Generate default mock response for common tools
179 | return m.generateMockToolResponse(toolName, arguments)
180 | }
181 |
182 | // Execute the actual tool with mocked dependencies
183 | return tool.Execute(ctx, arguments)
184 | }
185 |
186 | // generateMockToolResponse generates default responses for common AWS tools
187 | func (m *MockMCPServer) generateMockToolResponse(toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
188 | // If AWS client is available, use AWS client versions for better integration
189 | if m.awsClient != nil {
190 | return m.generateMockToolResponseWithAWSClient(toolName, arguments)
191 | }
192 |
193 | // Fallback to static responses when no AWS client is available
194 | return m.generateMockToolResponseFallback(toolName, arguments)
195 | }
196 |
197 | // generateMockToolResponseWithAWSClient uses AWS client for realistic mock responses
198 | func (m *MockMCPServer) generateMockToolResponseWithAWSClient(toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
199 | switch {
200 | // VPC Tools
201 | case toolName == "create-vpc":
202 | return m.mockCreateVPCWithAWSClient(arguments)
203 | case toolName == "list-vpcs":
204 | return m.mockListVPCsWithAWSClient(arguments)
205 | case toolName == "get-default-vpc":
206 | return m.mockGetDefaultVPC(arguments)
207 |
208 | // Subnet Tools
209 | case toolName == "create-subnet":
210 | return m.mockCreateSubnetWithAWSClient(arguments)
211 | case toolName == "create-private-subnet":
212 | return m.mockCreatePrivateSubnet(arguments)
213 | case toolName == "create-public-subnet":
214 | return m.mockCreatePublicSubnet(arguments)
215 | case toolName == "list-subnets":
216 | return m.mockListSubnets(arguments)
217 | case toolName == "list-subnets-for-alb":
218 | return m.mockSelectSubnetsForALB(arguments)
219 |
220 | // Networking Infrastructure Tools
221 | case toolName == "create-internet-gateway":
222 | return m.mockCreateInternetGateway(arguments)
223 | case toolName == "create-nat-gateway":
224 | return m.mockCreateNATGateway(arguments)
225 | case toolName == "create-public-route-table":
226 | return m.mockCreatePublicRouteTable(arguments)
227 | case toolName == "create-private-route-table":
228 | return m.mockCreatePrivateRouteTable(arguments)
229 | case toolName == "associate-route-table":
230 | return m.mockAssociateRouteTable(arguments)
231 | case toolName == "add-route":
232 | return m.mockAddRoute(arguments)
233 |
234 | // EC2 Tools
235 | case toolName == "create-ec2-instance":
236 | return m.mockCreateEC2InstanceWithAWSClient(arguments)
237 | case toolName == "list-ec2-instances":
238 | return m.mockListEC2Instances(arguments)
239 | case toolName == "start-ec2-instance":
240 | return m.mockStartEC2Instance(arguments)
241 | case toolName == "stop-ec2-instance":
242 | return m.mockStopEC2Instance(arguments)
243 | case toolName == "terminate-ec2-instance":
244 | return m.mockTerminateEC2Instance(arguments)
245 | case toolName == "create-ami-from-instance":
246 | return m.mockCreateAMIFromInstance(arguments)
247 | case toolName == "list-amis":
248 | return m.mockListAMIs(arguments)
249 | case toolName == "get-latest-ami":
250 | return m.mockGetLatestAMI(arguments)
251 | case toolName == "get-latest-amazon-linux-ami":
252 | return m.mockGetLatestAmazonLinuxAMI(arguments)
253 | case toolName == "get-latest-ubuntu-ami":
254 | return m.mockGetLatestUbuntuAMI(arguments)
255 |
256 | // Load Balancer Tools
257 | case toolName == "create-load-balancer":
258 | return m.mockCreateLoadBalancer(arguments)
259 | case toolName == "create-target-group":
260 | return m.mockCreateTargetGroup(arguments)
261 | case toolName == "create-listener":
262 | return m.mockCreateListener(arguments)
263 | case toolName == "list-load-balancers":
264 | return m.mockListLoadBalancers(arguments)
265 | case toolName == "list-target-groups":
266 | return m.mockListTargetGroups(arguments)
267 | case toolName == "register-targets":
268 | return m.mockRegisterTargets(arguments)
269 | case toolName == "deregister-targets":
270 | return m.mockDeregisterTargets(arguments)
271 |
272 | // RDS Tools
273 | case toolName == "create-db-subnet-group":
274 | return m.mockCreateDBSubnetGroup(arguments)
275 | case toolName == "create-db-instance":
276 | return m.mockCreateDBInstance(arguments)
277 | case toolName == "start-db-instance":
278 | return m.mockStartDBInstance(arguments)
279 | case toolName == "stop-db-instance":
280 | return m.mockStopDBInstance(arguments)
281 | case toolName == "delete-db-instance":
282 | return m.mockDeleteDBInstance(arguments)
283 | case toolName == "create-db-snapshot":
284 | return m.mockCreateDBSnapshot(arguments)
285 | case toolName == "list-db-instances":
286 | return m.mockListDBInstances(arguments)
287 | case toolName == "list-db-snapshots":
288 | return m.mockListDBSnapshots(arguments)
289 |
290 | // Security Group Tools
291 | case toolName == "create-security-group":
292 | return m.mockCreateSecurityGroup(arguments)
293 | case toolName == "list-security-groups":
294 | return m.mockListSecurityGroups(arguments)
295 | case toolName == "add-security-group-ingress-rule":
296 | return m.mockAddSecurityGroupIngressRule(arguments)
297 | case toolName == "add-security-group-egress-rule":
298 | return m.mockAddSecurityGroupEgressRule(arguments)
299 | case toolName == "delete-security-group":
300 | return m.mockDeleteSecurityGroup(arguments)
301 |
302 | // Auto Scaling Tools
303 | case toolName == "create-launch-template":
304 | return m.mockCreateLaunchTemplate(arguments)
305 | case toolName == "create-auto-scaling-group":
306 | return m.mockCreateAutoScalingGroup(arguments)
307 | case toolName == "list-auto-scaling-groups":
308 | return m.mockListAutoScalingGroups(arguments)
309 | case toolName == "list-launch-templates":
310 | return m.mockListLaunchTemplates(arguments)
311 |
312 | // State Tools
313 | case toolName == "export-infrastructure-state":
314 | return m.mockExportInfrastructureState(arguments)
315 | case toolName == "analyze-infrastructure-state":
316 | return m.mockAnalyzeInfrastructureState(arguments)
317 | case toolName == "visualize-dependency-graph":
318 | return m.mockVisualizeDependencyGraph(arguments)
319 | case toolName == "detect-infrastructure-conflicts":
320 | return m.mockDetectInfrastructureConflicts(arguments)
321 | case toolName == "plan-infrastructure-deployment":
322 | return m.mockPlanInfrastructureDeployment(arguments)
323 | case toolName == "add-resource-to-state":
324 | return m.mockAddResourceToState(arguments)
325 | case toolName == "save-state":
326 | return m.mockSaveState(arguments)
327 |
328 | // Utility Tools
329 | case toolName == "get-availability-zones":
330 | return m.mockGetAvailabilityZones(arguments)
331 |
332 | default:
333 | return &mcp.CallToolResult{
334 | IsError: true,
335 | Content: []mcp.Content{
336 | &mcp.TextContent{
337 | Type: "text",
338 | Text: fmt.Sprintf("Mock tool '%s' not implemented", toolName),
339 | },
340 | },
341 | }, nil
342 | }
343 | }
344 |
345 | // generateMockToolResponseFallback provides static responses when no AWS client is available
346 | func (m *MockMCPServer) generateMockToolResponseFallback(toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
347 | switch {
348 | // VPC Tools
349 | case toolName == "create-vpc":
350 | return m.mockCreateVPC(arguments)
351 | case toolName == "list-vpcs":
352 | return m.mockListVPCs(arguments)
353 | case toolName == "get-default-vpc":
354 | return m.mockGetDefaultVPC(arguments)
355 |
356 | // Subnet Tools
357 | case toolName == "create-subnet":
358 | return m.mockCreateSubnet(arguments)
359 | case toolName == "create-private-subnet":
360 | return m.mockCreatePrivateSubnet(arguments)
361 | case toolName == "create-public-subnet":
362 | return m.mockCreatePublicSubnet(arguments)
363 | case toolName == "list-subnets":
364 | return m.mockListSubnets(arguments)
365 | case toolName == "list-subnets-for-alb":
366 | return m.mockSelectSubnetsForALB(arguments)
367 |
368 | // Networking Infrastructure Tools
369 | case toolName == "create-internet-gateway":
370 | return m.mockCreateInternetGateway(arguments)
371 | case toolName == "create-nat-gateway":
372 | return m.mockCreateNATGateway(arguments)
373 | case toolName == "create-public-route-table":
374 | return m.mockCreatePublicRouteTable(arguments)
375 | case toolName == "create-private-route-table":
376 | return m.mockCreatePrivateRouteTable(arguments)
377 | case toolName == "associate-route-table":
378 | return m.mockAssociateRouteTable(arguments)
379 | case toolName == "add-route":
380 | return m.mockAddRoute(arguments)
381 |
382 | // EC2 Tools
383 | case toolName == "create-ec2-instance":
384 | return m.mockCreateEC2Instance(arguments)
385 | case toolName == "list-ec2-instances":
386 | return m.mockListEC2Instances(arguments)
387 | case toolName == "start-ec2-instance":
388 | return m.mockStartEC2Instance(arguments)
389 | case toolName == "stop-ec2-instance":
390 | return m.mockStopEC2Instance(arguments)
391 | case toolName == "terminate-ec2-instance":
392 | return m.mockTerminateEC2Instance(arguments)
393 | case toolName == "create-ami-from-instance":
394 | return m.mockCreateAMIFromInstance(arguments)
395 | case toolName == "list-amis":
396 | return m.mockListAMIs(arguments)
397 | case toolName == "get-latest-ami":
398 | return m.mockGetLatestAMI(arguments)
399 | case toolName == "get-latest-amazon-linux-ami":
400 | return m.mockGetLatestAmazonLinuxAMI(arguments)
401 | case toolName == "get-latest-ubuntu-ami":
402 | return m.mockGetLatestUbuntuAMI(arguments)
403 |
404 | // Load Balancer Tools
405 | case toolName == "create-load-balancer":
406 | return m.mockCreateLoadBalancer(arguments)
407 | case toolName == "create-target-group":
408 | return m.mockCreateTargetGroup(arguments)
409 | case toolName == "create-listener":
410 | return m.mockCreateListener(arguments)
411 | case toolName == "list-load-balancers":
412 | return m.mockListLoadBalancers(arguments)
413 | case toolName == "list-target-groups":
414 | return m.mockListTargetGroups(arguments)
415 | case toolName == "register-targets":
416 | return m.mockRegisterTargets(arguments)
417 | case toolName == "deregister-targets":
418 | return m.mockDeregisterTargets(arguments)
419 |
420 | // RDS Tools
421 | case toolName == "create-db-subnet-group":
422 | return m.mockCreateDBSubnetGroup(arguments)
423 | case toolName == "create-db-instance":
424 | return m.mockCreateDBInstance(arguments)
425 | case toolName == "start-db-instance":
426 | return m.mockStartDBInstance(arguments)
427 | case toolName == "stop-db-instance":
428 | return m.mockStopDBInstance(arguments)
429 | case toolName == "delete-db-instance":
430 | return m.mockDeleteDBInstance(arguments)
431 | case toolName == "create-db-snapshot":
432 | return m.mockCreateDBSnapshot(arguments)
433 | case toolName == "list-db-instances":
434 | return m.mockListDBInstances(arguments)
435 | case toolName == "list-db-snapshots":
436 | return m.mockListDBSnapshots(arguments)
437 |
438 | // Security Group Tools
439 | case toolName == "create-security-group":
440 | return m.mockCreateSecurityGroup(arguments)
441 | case toolName == "list-security-groups":
442 | return m.mockListSecurityGroups(arguments)
443 | case toolName == "add-security-group-ingress-rule":
444 | return m.mockAddSecurityGroupIngressRule(arguments)
445 | case toolName == "add-security-group-egress-rule":
446 | return m.mockAddSecurityGroupEgressRule(arguments)
447 | case toolName == "delete-security-group":
448 | return m.mockDeleteSecurityGroup(arguments)
449 |
450 | // Auto Scaling Tools
451 | case toolName == "create-launch-template":
452 | return m.mockCreateLaunchTemplate(arguments)
453 | case toolName == "create-auto-scaling-group":
454 | return m.mockCreateAutoScalingGroup(arguments)
455 | case toolName == "list-auto-scaling-groups":
456 | return m.mockListAutoScalingGroups(arguments)
457 | case toolName == "list-launch-templates":
458 | return m.mockListLaunchTemplates(arguments)
459 |
460 | // State Tools
461 | case toolName == "export-infrastructure-state":
462 | return m.mockExportInfrastructureState(arguments)
463 | case toolName == "analyze-infrastructure-state":
464 | return m.mockAnalyzeInfrastructureState(arguments)
465 | case toolName == "visualize-dependency-graph":
466 | return m.mockVisualizeDependencyGraph(arguments)
467 | case toolName == "detect-infrastructure-conflicts":
468 | return m.mockDetectInfrastructureConflicts(arguments)
469 | case toolName == "plan-infrastructure-deployment":
470 | return m.mockPlanInfrastructureDeployment(arguments)
471 | case toolName == "add-resource-to-state":
472 | return m.mockAddResourceToState(arguments)
473 | case toolName == "save-state":
474 | return m.mockSaveState(arguments)
475 |
476 | // Utility Tools
477 | case toolName == "get-availability-zones":
478 | return m.mockGetAvailabilityZones(arguments)
479 |
480 | default:
481 | return &mcp.CallToolResult{
482 | IsError: true,
483 | Content: []mcp.Content{
484 | &mcp.TextContent{
485 | Type: "text",
486 | Text: fmt.Sprintf("Mock tool '%s' not implemented", toolName),
487 | },
488 | },
489 | }, nil
490 | }
491 | }
492 |
493 | // VPC Mock Responses
494 | func (m *MockMCPServer) mockCreateVPC(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
495 | name, _ := arguments["name"].(string)
496 | cidrBlock, _ := arguments["cidrBlock"].(string)
497 |
498 | if name == "" {
499 | name = "test-vpc"
500 | }
501 | if cidrBlock == "" {
502 | cidrBlock = "10.0.0.0/16"
503 | }
504 |
505 | vpcId := m.generateMockResourceId("vpc")
506 |
507 | response := map[string]interface{}{
508 | "vpcId": vpcId,
509 | "name": name,
510 | "cidrBlock": cidrBlock,
511 | "state": "available",
512 | "isDefault": false,
513 | "resource": map[string]interface{}{
514 | "id": vpcId,
515 | "type": "vpc",
516 | "name": name,
517 | },
518 | }
519 |
520 | // Store resource for later retrieval
521 | m.resources[vpcId] = &types.AWSResource{
522 | ID: vpcId,
523 | Type: "vpc",
524 | Details: map[string]interface{}{
525 | "name": name,
526 | "cidrBlock": cidrBlock,
527 | "state": "available",
528 | },
529 | }
530 |
531 | return m.createSuccessResponse(fmt.Sprintf("VPC '%s' created successfully", name), response)
532 | }
533 |
534 | // mockCreateVPCWithAWSClient uses the MockAWSClient for VPC creation
535 | func (m *MockMCPServer) mockCreateVPCWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
536 | name, _ := arguments["name"].(string)
537 | cidrBlock, _ := arguments["cidrBlock"].(string)
538 |
539 | if name == "" {
540 | name = "test-vpc"
541 | }
542 | if cidrBlock == "" {
543 | cidrBlock = "10.0.0.0/16"
544 | }
545 |
546 | // Use the actual AWS mock client
547 | params := aws.CreateVPCParams{
548 | CidrBlock: cidrBlock,
549 | Name: name,
550 | Tags: map[string]string{
551 | "Name": name,
552 | },
553 | }
554 |
555 | ctx := context.Background()
556 | awsResource, err := m.awsClient.CreateVPC(ctx, params)
557 | if err != nil {
558 | return &mcp.CallToolResult{
559 | IsError: true,
560 | Content: []mcp.Content{
561 | &mcp.TextContent{
562 | Type: "text",
563 | Text: fmt.Sprintf("Failed to create VPC: %v", err),
564 | },
565 | },
566 | }, err
567 | }
568 |
569 | response := map[string]interface{}{
570 | "vpcId": awsResource.ID,
571 | "name": name,
572 | "cidrBlock": cidrBlock,
573 | "state": awsResource.State,
574 | "isDefault": false,
575 | "resource": map[string]interface{}{
576 | "id": awsResource.ID,
577 | "type": awsResource.Type,
578 | "name": name,
579 | "region": awsResource.Region,
580 | },
581 | }
582 |
583 | return m.createSuccessResponse(fmt.Sprintf("VPC '%s' created successfully", name), response)
584 | }
585 |
586 | func (m *MockMCPServer) mockListVPCs(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
587 | vpcs := []map[string]interface{}{
588 | {
589 | "vpcId": "vpc-default123",
590 | "name": "default-vpc",
591 | "cidrBlock": "172.31.0.0/16",
592 | "state": "available",
593 | "isDefault": true,
594 | },
595 | {
596 | "vpcId": "vpc-prod123",
597 | "name": "production-vpc",
598 | "cidrBlock": "10.0.0.0/16",
599 | "state": "available",
600 | "isDefault": false,
601 | },
602 | }
603 |
604 | response := map[string]interface{}{
605 | "vpcs": vpcs,
606 | "count": len(vpcs),
607 | }
608 |
609 | return m.createSuccessResponse(fmt.Sprintf("Found %d VPCs", len(vpcs)), response)
610 | }
611 |
612 | // mockListVPCsWithAWSClient uses the MockAWSClient for VPC listing
613 | func (m *MockMCPServer) mockListVPCsWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
614 | ctx := context.Background()
615 | awsVPCs, err := m.awsClient.DescribeVPCs(ctx)
616 | if err != nil {
617 | return &mcp.CallToolResult{
618 | IsError: true,
619 | Content: []mcp.Content{
620 | &mcp.TextContent{
621 | Type: "text",
622 | Text: fmt.Sprintf("Failed to list VPCs: %v", err),
623 | },
624 | },
625 | }, err
626 | }
627 |
628 | vpcs := make([]map[string]interface{}, 0, len(awsVPCs))
629 | for _, vpc := range awsVPCs {
630 | vpcs = append(vpcs, map[string]interface{}{
631 | "vpcId": vpc.ID,
632 | "name": vpc.Details["name"],
633 | "cidrBlock": vpc.Details["cidrBlock"],
634 | "state": vpc.State,
635 | "isDefault": false, // Mock doesn't track default VPCs
636 | })
637 | }
638 |
639 | response := map[string]interface{}{
640 | "vpcs": vpcs,
641 | "count": len(vpcs),
642 | }
643 |
644 | return m.createSuccessResponse(fmt.Sprintf("Found %d VPCs", len(vpcs)), response)
645 | }
646 |
647 | func (m *MockMCPServer) mockGetDefaultVPC(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
648 | response := map[string]interface{}{
649 | "value": "vpc-default123",
650 | "vpcId": "vpc-default123",
651 | "name": "default-vpc",
652 | "cidrBlock": "172.31.0.0/16",
653 | "state": "available",
654 | "source": "aws_api_call",
655 | }
656 |
657 | return m.createSuccessResponse("Found default VPC", response)
658 | }
659 |
660 | // Subnet Mock Responses
661 | func (m *MockMCPServer) mockCreateSubnet(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
662 | name, _ := arguments["name"].(string)
663 | vpcId, _ := arguments["vpcId"].(string)
664 | cidrBlock, _ := arguments["cidrBlock"].(string)
665 | availabilityZone, _ := arguments["availabilityZone"].(string)
666 |
667 | if name == "" {
668 | name = "test-subnet"
669 | }
670 | if vpcId == "" {
671 | vpcId = "vpc-default123"
672 | }
673 | if cidrBlock == "" {
674 | cidrBlock = "10.0.1.0/24"
675 | }
676 | if availabilityZone == "" {
677 | availabilityZone = "us-west-2a"
678 | }
679 |
680 | subnetId := m.generateMockResourceId("subnet")
681 |
682 | response := map[string]interface{}{
683 | "subnetId": subnetId,
684 | "name": name,
685 | "vpcId": vpcId,
686 | "cidrBlock": cidrBlock,
687 | "availabilityZone": availabilityZone,
688 | "state": "available",
689 | "resource": map[string]interface{}{
690 | "id": subnetId,
691 | "type": "subnet",
692 | "name": name,
693 | },
694 | }
695 |
696 | return m.createSuccessResponse(fmt.Sprintf("Subnet '%s' created successfully", name), response)
697 | }
698 |
699 | // mockCreateSubnetWithAWSClient uses the MockAWSClient for subnet creation
700 | func (m *MockMCPServer) mockCreateSubnetWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
701 | name, _ := arguments["name"].(string)
702 | vpcId, _ := arguments["vpcId"].(string)
703 | cidrBlock, _ := arguments["cidrBlock"].(string)
704 | availabilityZone, _ := arguments["availabilityZone"].(string)
705 |
706 | if name == "" {
707 | name = "test-subnet"
708 | }
709 | if vpcId == "" {
710 | vpcId = "vpc-default123"
711 | }
712 | if cidrBlock == "" {
713 | cidrBlock = "10.0.1.0/24"
714 | }
715 | if availabilityZone == "" {
716 | availabilityZone = "us-west-2a"
717 | }
718 |
719 | // Use the actual AWS mock client
720 | params := aws.CreateSubnetParams{
721 | VpcID: vpcId,
722 | CidrBlock: cidrBlock,
723 | AvailabilityZone: availabilityZone,
724 | Name: name,
725 | }
726 |
727 | ctx := context.Background()
728 | awsResource, err := m.awsClient.CreateSubnet(ctx, params)
729 | if err != nil {
730 | return &mcp.CallToolResult{
731 | IsError: true,
732 | Content: []mcp.Content{
733 | &mcp.TextContent{
734 | Type: "text",
735 | Text: fmt.Sprintf("Failed to create subnet: %v", err),
736 | },
737 | },
738 | }, err
739 | }
740 |
741 | response := map[string]interface{}{
742 | "subnetId": awsResource.ID,
743 | "name": name,
744 | "vpcId": vpcId,
745 | "cidrBlock": cidrBlock,
746 | "availabilityZone": availabilityZone,
747 | "state": awsResource.State,
748 | "resource": map[string]interface{}{
749 | "id": awsResource.ID,
750 | "type": awsResource.Type,
751 | "name": name,
752 | "region": awsResource.Region,
753 | },
754 | }
755 |
756 | return m.createSuccessResponse(fmt.Sprintf("Subnet '%s' created successfully", name), response)
757 | }
758 |
759 | func (m *MockMCPServer) mockSelectSubnetsForALB(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
760 | scheme, _ := arguments["scheme"].(string)
761 | vpcId, _ := arguments["vpcId"].(string)
762 |
763 | if vpcId == "" {
764 | vpcId = "vpc-default123"
765 | }
766 |
767 | subnetIds := []string{"subnet-12345", "subnet-67890"}
768 |
769 | response := map[string]interface{}{
770 | "subnetIds": subnetIds,
771 | "vpcId": vpcId,
772 | "scheme": scheme,
773 | "count": len(subnetIds),
774 | }
775 |
776 | responseText, _ := json.Marshal(response)
777 | return &mcp.CallToolResult{
778 | IsError: false,
779 | Content: []mcp.Content{
780 | &mcp.TextContent{
781 | Type: "text",
782 | Text: string(responseText),
783 | },
784 | },
785 | }, nil
786 | }
787 |
788 | // EC2 Mock Responses
789 | func (m *MockMCPServer) mockGetLatestAMI(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
790 | response := map[string]interface{}{
791 | "value": "ami-latest123",
792 | "imageId": "ami-latest123",
793 | "name": "amzn2-ami-hvm-2.0.20231101.0-x86_64-gp2",
794 | "description": "Amazon Linux 2 AMI",
795 | "source": "aws_api_call",
796 | }
797 |
798 | return m.createSuccessResponse("Found latest AMI", response)
799 | }
800 |
801 | func (m *MockMCPServer) mockCreateEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
802 | name, _ := arguments["name"].(string)
803 | imageId, _ := arguments["imageId"].(string)
804 | instanceType, _ := arguments["instanceType"].(string)
805 |
806 | if name == "" {
807 | name = "test-instance"
808 | }
809 | if imageId == "" {
810 | imageId = "ami-latest123"
811 | }
812 | if instanceType == "" {
813 | instanceType = "t3.medium"
814 | }
815 |
816 | instanceId := m.generateMockResourceId("i")
817 |
818 | response := map[string]interface{}{
819 | "instanceId": instanceId,
820 | "name": name,
821 | "imageId": imageId,
822 | "instanceType": instanceType,
823 | "state": "running",
824 | "resource": map[string]interface{}{
825 | "id": instanceId,
826 | "type": "ec2_instance",
827 | "name": name,
828 | },
829 | }
830 |
831 | return m.createSuccessResponse(fmt.Sprintf("EC2 instance '%s' created successfully", name), response)
832 | }
833 |
834 | // mockCreateEC2InstanceWithAWSClient uses the MockAWSClient for EC2 instance creation
835 | func (m *MockMCPServer) mockCreateEC2InstanceWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
836 | name, _ := arguments["name"].(string)
837 | imageId, _ := arguments["imageId"].(string)
838 | instanceType, _ := arguments["instanceType"].(string)
839 | keyName, _ := arguments["keyName"].(string)
840 | securityGroupId, _ := arguments["securityGroupId"].(string)
841 | subnetId, _ := arguments["subnetId"].(string)
842 |
843 | if name == "" {
844 | name = "test-instance"
845 | }
846 | if imageId == "" {
847 | imageId = "ami-12345678" // Valid mock AMI ID format
848 | }
849 | if instanceType == "" {
850 | instanceType = "t3.micro"
851 | }
852 |
853 | // Use the actual AWS mock client
854 | params := aws.CreateInstanceParams{
855 | ImageID: imageId,
856 | InstanceType: instanceType,
857 | KeyName: keyName,
858 | SecurityGroupID: securityGroupId,
859 | SubnetID: subnetId,
860 | }
861 |
862 | ctx := context.Background()
863 | awsResource, err := m.awsClient.CreateEC2Instance(ctx, params)
864 | if err != nil {
865 | return &mcp.CallToolResult{
866 | IsError: true,
867 | Content: []mcp.Content{
868 | &mcp.TextContent{
869 | Type: "text",
870 | Text: fmt.Sprintf("Failed to create EC2 instance: %v", err),
871 | },
872 | },
873 | }, err
874 | }
875 |
876 | response := map[string]interface{}{
877 | "instanceId": awsResource.ID,
878 | "name": name,
879 | "imageId": imageId,
880 | "instanceType": instanceType,
881 | "state": awsResource.State,
882 | "resource": map[string]interface{}{
883 | "id": awsResource.ID,
884 | "type": awsResource.Type,
885 | "name": name,
886 | "region": awsResource.Region,
887 | },
888 | }
889 |
890 | return m.createSuccessResponse(fmt.Sprintf("EC2 instance '%s' created successfully", name), response)
891 | }
892 |
893 | // Load Balancer Mock Responses
894 | func (m *MockMCPServer) mockCreateLoadBalancer(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
895 | name, _ := arguments["name"].(string)
896 | scheme, _ := arguments["scheme"].(string)
897 | lbType, _ := arguments["type"].(string)
898 |
899 | if name == "" {
900 | name = "test-alb"
901 | }
902 | if scheme == "" {
903 | scheme = "internet-facing"
904 | }
905 | if lbType == "" {
906 | lbType = "application"
907 | }
908 |
909 | loadBalancerArn := fmt.Sprintf("arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/%s/%s",
910 | name, m.generateMockResourceId(""))
911 |
912 | response := map[string]interface{}{
913 | "name": name,
914 | "scheme": scheme,
915 | "type": lbType,
916 | "loadBalancerId": loadBalancerArn,
917 | "loadBalancerArn": loadBalancerArn,
918 | "arn": loadBalancerArn,
919 | "resource": map[string]interface{}{
920 | "id": loadBalancerArn,
921 | "type": "load_balancer",
922 | "name": name,
923 | },
924 | }
925 |
926 | return m.createSuccessResponse(fmt.Sprintf("Load balancer '%s' created successfully", name), response)
927 | }
928 |
929 | func (m *MockMCPServer) mockCreateTargetGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
930 | name, _ := arguments["name"].(string)
931 | vpcId, _ := arguments["vpcId"].(string)
932 | protocol, _ := arguments["protocol"].(string)
933 | port, _ := arguments["port"].(float64)
934 |
935 | if name == "" {
936 | name = "test-tg"
937 | }
938 | if vpcId == "" {
939 | vpcId = "vpc-default123"
940 | }
941 | if protocol == "" {
942 | protocol = "HTTP"
943 | }
944 | if port == 0 {
945 | port = 80
946 | }
947 |
948 | targetGroupArn := fmt.Sprintf("arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/%s/%s",
949 | name, m.generateMockResourceId(""))
950 |
951 | response := map[string]interface{}{
952 | "name": name,
953 | "vpcId": vpcId,
954 | "protocol": protocol,
955 | "port": int(port),
956 | "targetGroupId": targetGroupArn,
957 | "targetGroupArn": targetGroupArn,
958 | "arn": targetGroupArn,
959 | "resource": map[string]interface{}{
960 | "id": targetGroupArn,
961 | "type": "target_group",
962 | "name": name,
963 | },
964 | }
965 |
966 | return m.createSuccessResponse(fmt.Sprintf("Target group '%s' created successfully", name), response)
967 | }
968 |
969 | // State Mock Responses
970 | func (m *MockMCPServer) mockExportInfrastructureState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
971 | return m.stateManager.ExportState(arguments)
972 | }
973 |
974 | // Utility Mock Responses
975 | func (m *MockMCPServer) mockGetAvailabilityZones(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
976 | zones := []string{"ap-southeast-1a", "ap-southeast-1b", "ap-southeast-1c"}
977 |
978 | response := map[string]interface{}{
979 | "zones": zones,
980 | "count": len(zones),
981 | "allZones": zones,
982 | "allCount": len(zones),
983 | "availabilityZone": zones[0], // First AZ for {{step-id.availabilityZone}} resolution
984 | "value": zones[0], // For {{step-id.resourceId}} resolution
985 | "zone_names": zones, // Alternative access pattern
986 | }
987 |
988 | return m.createSuccessResponse(fmt.Sprintf("Retrieved %d availability zones", len(zones)), response)
989 | }
990 |
991 | // Utility methods
992 | func (m *MockMCPServer) generateMockResourceId(prefix string) string {
993 | if prefix == "" {
994 | return fmt.Sprintf("%08d", len(m.resources)+1)
995 | }
996 | return fmt.Sprintf("%s-%08d", prefix, len(m.resources)+1)
997 | }
998 |
999 | func (m *MockMCPServer) createSuccessResponse(message string, data interface{}) (*mcp.CallToolResult, error) {
1000 | responseData, _ := json.Marshal(data)
1001 |
1002 | return &mcp.CallToolResult{
1003 | IsError: false,
1004 | Content: []mcp.Content{
1005 | &mcp.TextContent{
1006 | Type: "text",
1007 | Text: string(responseData),
1008 | },
1009 | },
1010 | }, nil
1011 | }
1012 |
1013 | // Configuration methods
1014 | func (m *MockMCPServer) SimulateError(toolName string, err error) {
1015 | m.mutex.Lock()
1016 | defer m.mutex.Unlock()
1017 | m.simulateErrors[toolName] = err
1018 | }
1019 |
1020 | func (m *MockMCPServer) SetCustomResponse(toolName string, response *mcp.CallToolResult) {
1021 | m.mutex.Lock()
1022 | defer m.mutex.Unlock()
1023 | m.customResponses[toolName] = response
1024 | }
1025 |
1026 | func (m *MockMCPServer) ClearError(toolName string) {
1027 | m.mutex.Lock()
1028 | defer m.mutex.Unlock()
1029 | delete(m.simulateErrors, toolName)
1030 | }
1031 |
1032 | func (m *MockMCPServer) ClearAllErrors() {
1033 | m.mutex.Lock()
1034 | defer m.mutex.Unlock()
1035 | m.simulateErrors = make(map[string]error)
1036 | }
1037 |
1038 | // Additional mock methods for missing implementations
1039 | func (m *MockMCPServer) mockListSubnets(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1040 | subnets := []map[string]interface{}{
1041 | {
1042 | "subnetId": "subnet-0def123abc456789",
1043 | "name": "default-subnet",
1044 | "vpcId": "vpc-default123",
1045 | "cidrBlock": "172.31.1.0/24",
1046 | "availabilityZone": "us-west-2a",
1047 | "state": "available",
1048 | },
1049 | {
1050 | "subnetId": "subnet-12345",
1051 | "name": "public-subnet-1",
1052 | "vpcId": "vpc-prod123",
1053 | "cidrBlock": "10.0.1.0/24",
1054 | "availabilityZone": "us-west-2a",
1055 | "state": "available",
1056 | },
1057 | }
1058 |
1059 | // Extract subnet IDs for dependency resolution
1060 | subnetIDs := []string{"subnet-0def123abc456789", "subnet-0abc12345678"}
1061 |
1062 | response := map[string]interface{}{
1063 | "subnets": subnets, // Subnet details
1064 | "subnetId": subnetIDs[0], // First subnet for dependency resolution
1065 | "value": subnetIDs[0], // For {{step-id.resourceId}} resolution
1066 | "subnet_ids": subnetIDs, // Full list for comprehensive access
1067 | }
1068 |
1069 | return m.createSuccessResponse(fmt.Sprintf("Found %d subnets", len(subnets)), response)
1070 | }
1071 |
1072 | func (m *MockMCPServer) mockListEC2Instances(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1073 | instances := []map[string]interface{}{
1074 | {
1075 | "instanceId": "i-sample123",
1076 | "name": "sample-instance",
1077 | "imageId": "ami-latest123",
1078 | "instanceType": "t3.medium",
1079 | "state": "running",
1080 | },
1081 | }
1082 |
1083 | response := map[string]interface{}{
1084 | "instances": instances,
1085 | "count": len(instances),
1086 | }
1087 |
1088 | return m.createSuccessResponse(fmt.Sprintf("Found %d instances", len(instances)), response)
1089 | }
1090 |
1091 | func (m *MockMCPServer) mockCreateSecurityGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1092 | name, _ := arguments["name"].(string)
1093 | vpcId, _ := arguments["vpcId"].(string)
1094 | description, _ := arguments["description"].(string)
1095 |
1096 | if name == "" {
1097 | name = "test-sg"
1098 | }
1099 | if vpcId == "" {
1100 | vpcId = "vpc-default123"
1101 | }
1102 | if description == "" {
1103 | description = "Test security group"
1104 | }
1105 |
1106 | groupId := m.generateMockResourceId("sg")
1107 |
1108 | response := map[string]interface{}{
1109 | "groupId": groupId,
1110 | "securityGroupId": groupId,
1111 | "name": name,
1112 | "vpcId": vpcId,
1113 | "description": description,
1114 | "resource": map[string]interface{}{
1115 | "id": groupId,
1116 | "type": "security_group",
1117 | "name": name,
1118 | },
1119 | }
1120 |
1121 | return m.createSuccessResponse(fmt.Sprintf("Security group '%s' created successfully", name), response)
1122 | }
1123 |
1124 | func (m *MockMCPServer) mockCreateListener(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1125 | loadBalancerArn, _ := arguments["loadBalancerArn"].(string)
1126 | targetGroupArn, _ := arguments["targetGroupArn"].(string)
1127 | protocol, _ := arguments["protocol"].(string)
1128 | port, _ := arguments["port"].(float64)
1129 |
1130 | if protocol == "" {
1131 | protocol = "HTTP"
1132 | }
1133 | if port == 0 {
1134 | port = 80
1135 | }
1136 |
1137 | // Validate ARN formats - be lenient for testing, allow mock IDs
1138 | if loadBalancerArn != "" && !strings.HasPrefix(loadBalancerArn, "arn:aws:elasticloadbalancing:") && !strings.HasPrefix(loadBalancerArn, "mock-") {
1139 | return &mcp.CallToolResult{
1140 | IsError: true,
1141 | Content: []mcp.Content{
1142 | &mcp.TextContent{
1143 | Type: "text",
1144 | Text: fmt.Sprintf("loadBalancerArn must be in ARN format, received: '%s'", loadBalancerArn),
1145 | },
1146 | },
1147 | }, nil
1148 | }
1149 |
1150 | if targetGroupArn != "" && !strings.HasPrefix(targetGroupArn, "arn:aws:elasticloadbalancing:") && !strings.HasPrefix(targetGroupArn, "mock-") {
1151 | return &mcp.CallToolResult{
1152 | IsError: true,
1153 | Content: []mcp.Content{
1154 | &mcp.TextContent{
1155 | Type: "text",
1156 | Text: fmt.Sprintf("targetGroupArn must be in ARN format, received: '%s'", targetGroupArn),
1157 | },
1158 | },
1159 | }, nil
1160 | }
1161 |
1162 | listenerId := m.generateMockResourceId("listener")
1163 |
1164 | response := map[string]interface{}{
1165 | "loadBalancerArn": loadBalancerArn,
1166 | "targetGroupArn": targetGroupArn,
1167 | "protocol": protocol,
1168 | "port": int(port),
1169 | "listenerId": listenerId,
1170 | "resource": map[string]interface{}{
1171 | "id": listenerId,
1172 | "type": "listener",
1173 | },
1174 | }
1175 |
1176 | return m.createSuccessResponse("Listener created successfully", response)
1177 | }
1178 |
1179 | // ==== Missing EC2 Mock Methods ====
1180 |
1181 | func (m *MockMCPServer) mockStartEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1182 | instanceId, _ := arguments["instanceId"].(string)
1183 |
1184 | if instanceId == "" {
1185 | return &mcp.CallToolResult{
1186 | IsError: true,
1187 | Content: []mcp.Content{
1188 | &mcp.TextContent{
1189 | Type: "text",
1190 | Text: "instanceId is required",
1191 | },
1192 | },
1193 | }, nil
1194 | }
1195 |
1196 | response := map[string]interface{}{
1197 | "instanceId": instanceId,
1198 | "previousState": "stopped",
1199 | "currentState": "running",
1200 | "resource": map[string]interface{}{
1201 | "id": instanceId,
1202 | "type": "ec2_instance",
1203 | },
1204 | }
1205 |
1206 | return m.createSuccessResponse(fmt.Sprintf("Instance %s started successfully", instanceId), response)
1207 | }
1208 |
1209 | func (m *MockMCPServer) mockStopEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1210 | instanceId, _ := arguments["instanceId"].(string)
1211 |
1212 | if instanceId == "" {
1213 | return &mcp.CallToolResult{
1214 | IsError: true,
1215 | Content: []mcp.Content{
1216 | &mcp.TextContent{
1217 | Type: "text",
1218 | Text: "instanceId is required",
1219 | },
1220 | },
1221 | }, nil
1222 | }
1223 |
1224 | response := map[string]interface{}{
1225 | "instanceId": instanceId,
1226 | "previousState": "running",
1227 | "currentState": "stopped",
1228 | "resource": map[string]interface{}{
1229 | "id": instanceId,
1230 | "type": "ec2_instance",
1231 | },
1232 | }
1233 |
1234 | return m.createSuccessResponse(fmt.Sprintf("Instance %s stopped successfully", instanceId), response)
1235 | }
1236 |
1237 | func (m *MockMCPServer) mockTerminateEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1238 | instanceId, _ := arguments["instanceId"].(string)
1239 |
1240 | if instanceId == "" {
1241 | return &mcp.CallToolResult{
1242 | IsError: true,
1243 | Content: []mcp.Content{
1244 | &mcp.TextContent{
1245 | Type: "text",
1246 | Text: "instanceId is required",
1247 | },
1248 | },
1249 | }, nil
1250 | }
1251 |
1252 | response := map[string]interface{}{
1253 | "instanceId": instanceId,
1254 | "previousState": "running",
1255 | "currentState": "terminated",
1256 | "resource": map[string]interface{}{
1257 | "id": instanceId,
1258 | "type": "ec2_instance",
1259 | },
1260 | }
1261 |
1262 | return m.createSuccessResponse(fmt.Sprintf("Instance %s terminated successfully", instanceId), response)
1263 | }
1264 |
1265 | func (m *MockMCPServer) mockCreateAMIFromInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1266 | instanceId, _ := arguments["instanceId"].(string)
1267 | name, _ := arguments["name"].(string)
1268 | description, _ := arguments["description"].(string)
1269 |
1270 | if instanceId == "" {
1271 | return &mcp.CallToolResult{
1272 | IsError: true,
1273 | Content: []mcp.Content{
1274 | &mcp.TextContent{
1275 | Type: "text",
1276 | Text: "instanceId is required",
1277 | },
1278 | },
1279 | }, nil
1280 | }
1281 |
1282 | if name == "" {
1283 | name = "custom-ami-" + m.generateMockResourceId("ami")
1284 | }
1285 |
1286 | amiId := m.generateMockResourceId("ami")
1287 |
1288 | response := map[string]interface{}{
1289 | "imageId": amiId,
1290 | "name": name,
1291 | "description": description,
1292 | "sourceInstanceId": instanceId,
1293 | "state": "available",
1294 | "resource": map[string]interface{}{
1295 | "id": amiId,
1296 | "type": "ami",
1297 | "name": name,
1298 | },
1299 | }
1300 |
1301 | return m.createSuccessResponse(fmt.Sprintf("AMI %s created from instance %s", amiId, instanceId), response)
1302 | }
1303 |
1304 | func (m *MockMCPServer) mockListAMIs(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1305 | amis := []map[string]interface{}{
1306 | {
1307 | "imageId": "ami-latest123",
1308 | "name": "amzn2-ami-hvm-2.0.20231101.0-x86_64-gp2",
1309 | "description": "Amazon Linux 2 AMI",
1310 | "state": "available",
1311 | "public": true,
1312 | },
1313 | {
1314 | "imageId": "ami-0abc123def456789",
1315 | "name": "ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20231020",
1316 | "description": "Canonical, Ubuntu, 22.04 LTS, amd64 jammy image",
1317 | "state": "available",
1318 | "public": true,
1319 | },
1320 | }
1321 |
1322 | response := map[string]interface{}{
1323 | "images": amis,
1324 | "count": len(amis),
1325 | }
1326 |
1327 | return m.createSuccessResponse(fmt.Sprintf("Found %d AMIs", len(amis)), response)
1328 | }
1329 |
1330 | func (m *MockMCPServer) mockGetLatestAmazonLinuxAMI(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1331 | response := map[string]interface{}{
1332 | "amiId": "ami-latest123",
1333 | "imageId": "ami-latest123",
1334 | "name": "amzn2-ami-hvm-2.0.20231101.0-x86_64-gp2",
1335 | "description": "Amazon Linux 2 AMI (HVM) - Kernel 5.10, SSD Volume Type",
1336 | "osType": "Linux",
1337 | "platform": "amazon-linux",
1338 | "architecture": "x86_64",
1339 | "state": "available",
1340 | "resource": map[string]interface{}{
1341 | "id": "ami-latest123",
1342 | "type": "ami",
1343 | },
1344 | }
1345 |
1346 | return m.createSuccessResponse("Found latest Amazon Linux 2 AMI: ami-latest123", response)
1347 | }
1348 |
1349 | func (m *MockMCPServer) mockGetLatestUbuntuAMI(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1350 | architecture, _ := arguments["architecture"].(string)
1351 | if architecture == "" {
1352 | architecture = "x86_64"
1353 | }
1354 |
1355 | response := map[string]interface{}{
1356 | "amiId": "ami-0abc123def456789",
1357 | "imageId": "ami-0abc123def456789",
1358 | "name": "ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20231020",
1359 | "description": "Canonical, Ubuntu, 22.04 LTS, amd64 jammy image build on 2023-10-20",
1360 | "osType": "Linux",
1361 | "platform": "ubuntu",
1362 | "architecture": architecture,
1363 | "state": "available",
1364 | "resource": map[string]interface{}{
1365 | "id": "ami-0abc123def456789",
1366 | "type": "ami",
1367 | },
1368 | }
1369 |
1370 | return m.createSuccessResponse("Found latest Ubuntu LTS AMI: ami-0abc123def456789", response)
1371 | }
1372 |
1373 | // ==== Missing Networking Mock Methods ====
1374 |
1375 | func (m *MockMCPServer) mockCreatePrivateSubnet(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1376 | vpcId, _ := arguments["vpcId"].(string)
1377 | cidrBlock, _ := arguments["cidrBlock"].(string)
1378 | availabilityZone, _ := arguments["availabilityZone"].(string)
1379 | name, _ := arguments["name"].(string)
1380 |
1381 | if vpcId == "" || cidrBlock == "" {
1382 | return &mcp.CallToolResult{
1383 | IsError: true,
1384 | Content: []mcp.Content{
1385 | &mcp.TextContent{
1386 | Type: "text",
1387 | Text: "vpcId and cidrBlock are required",
1388 | },
1389 | },
1390 | }, nil
1391 | }
1392 |
1393 | if name == "" {
1394 | name = "private-subnet"
1395 | }
1396 | if availabilityZone == "" {
1397 | availabilityZone = "us-west-2a"
1398 | }
1399 |
1400 | subnetId := m.generateMockResourceId("subnet")
1401 |
1402 | response := map[string]interface{}{
1403 | "subnetId": subnetId,
1404 | "vpcId": vpcId,
1405 | "cidrBlock": cidrBlock,
1406 | "availabilityZone": availabilityZone,
1407 | "name": name,
1408 | "mapPublicIpOnLaunch": false,
1409 | "state": "available",
1410 | "subnetType": "private",
1411 | "resource": map[string]interface{}{
1412 | "id": subnetId,
1413 | "type": "subnet",
1414 | "name": name,
1415 | },
1416 | }
1417 |
1418 | return m.createSuccessResponse(fmt.Sprintf("Private subnet '%s' created successfully", name), response)
1419 | }
1420 |
1421 | func (m *MockMCPServer) mockCreatePublicSubnet(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1422 | vpcId, _ := arguments["vpcId"].(string)
1423 | cidrBlock, _ := arguments["cidrBlock"].(string)
1424 | availabilityZone, _ := arguments["availabilityZone"].(string)
1425 | name, _ := arguments["name"].(string)
1426 |
1427 | if vpcId == "" || cidrBlock == "" {
1428 | return &mcp.CallToolResult{
1429 | IsError: true,
1430 | Content: []mcp.Content{
1431 | &mcp.TextContent{
1432 | Type: "text",
1433 | Text: "vpcId and cidrBlock are required",
1434 | },
1435 | },
1436 | }, nil
1437 | }
1438 |
1439 | if name == "" {
1440 | name = "public-subnet"
1441 | }
1442 | if availabilityZone == "" {
1443 | availabilityZone = "us-west-2a"
1444 | }
1445 |
1446 | subnetId := m.generateMockResourceId("subnet")
1447 |
1448 | response := map[string]interface{}{
1449 | "subnetId": subnetId,
1450 | "vpcId": vpcId,
1451 | "cidrBlock": cidrBlock,
1452 | "availabilityZone": availabilityZone,
1453 | "name": name,
1454 | "mapPublicIpOnLaunch": true,
1455 | "state": "available",
1456 | "subnetType": "public",
1457 | "resource": map[string]interface{}{
1458 | "id": subnetId,
1459 | "type": "subnet",
1460 | "name": name,
1461 | },
1462 | }
1463 |
1464 | return m.createSuccessResponse(fmt.Sprintf("Public subnet '%s' created successfully", name), response)
1465 | }
1466 |
1467 | func (m *MockMCPServer) mockCreateInternetGateway(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1468 | name, _ := arguments["name"].(string)
1469 | vpcId, _ := arguments["vpcId"].(string)
1470 |
1471 | if name == "" {
1472 | name = "test-igw"
1473 | }
1474 |
1475 | igwId := m.generateMockResourceId("igw")
1476 |
1477 | response := map[string]interface{}{
1478 | "internetGatewayId": igwId,
1479 | "name": name,
1480 | "state": "available",
1481 | "resource": map[string]interface{}{
1482 | "id": igwId,
1483 | "type": "internet_gateway",
1484 | "name": name,
1485 | },
1486 | }
1487 |
1488 | if vpcId != "" {
1489 | response["vpcId"] = vpcId
1490 | response["attachmentState"] = "attached"
1491 | }
1492 |
1493 | return m.createSuccessResponse(fmt.Sprintf("Internet gateway '%s' created successfully", name), response)
1494 | }
1495 |
1496 | func (m *MockMCPServer) mockCreateNATGateway(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1497 | subnetId, _ := arguments["subnetId"].(string)
1498 | name, _ := arguments["name"].(string)
1499 |
1500 | if subnetId == "" {
1501 | return &mcp.CallToolResult{
1502 | IsError: true,
1503 | Content: []mcp.Content{
1504 | &mcp.TextContent{
1505 | Type: "text",
1506 | Text: "subnetId is required",
1507 | },
1508 | },
1509 | }, nil
1510 | }
1511 |
1512 | if name == "" {
1513 | name = "test-nat-gw"
1514 | }
1515 |
1516 | natGwId := m.generateMockResourceId("nat")
1517 | eipId := m.generateMockResourceId("eip")
1518 |
1519 | response := map[string]interface{}{
1520 | "natGatewayId": natGwId,
1521 | "subnetId": subnetId,
1522 | "name": name,
1523 | "state": "available",
1524 | "publicIp": "1.2.3.4",
1525 | "allocationId": eipId,
1526 | "resource": map[string]interface{}{
1527 | "id": natGwId,
1528 | "type": "nat_gateway",
1529 | "name": name,
1530 | },
1531 | }
1532 |
1533 | return m.createSuccessResponse(fmt.Sprintf("NAT gateway '%s' created successfully", name), response)
1534 | }
1535 |
1536 | func (m *MockMCPServer) mockCreatePublicRouteTable(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1537 | vpcId, _ := arguments["vpcId"].(string)
1538 | name, _ := arguments["name"].(string)
1539 |
1540 | if vpcId == "" {
1541 | return &mcp.CallToolResult{
1542 | IsError: true,
1543 | Content: []mcp.Content{
1544 | &mcp.TextContent{
1545 | Type: "text",
1546 | Text: "vpcId is required",
1547 | },
1548 | },
1549 | }, nil
1550 | }
1551 |
1552 | if name == "" {
1553 | name = "public-route-table"
1554 | }
1555 |
1556 | routeTableId := m.generateMockResourceId("rtb")
1557 |
1558 | response := map[string]interface{}{
1559 | "routeTableId": routeTableId,
1560 | "vpcId": vpcId,
1561 | "name": name,
1562 | "routeType": "public",
1563 | "resource": map[string]interface{}{
1564 | "id": routeTableId,
1565 | "type": "route_table",
1566 | "name": name,
1567 | },
1568 | }
1569 |
1570 | return m.createSuccessResponse(fmt.Sprintf("Public route table '%s' created successfully", name), response)
1571 | }
1572 |
1573 | func (m *MockMCPServer) mockCreatePrivateRouteTable(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1574 | vpcId, _ := arguments["vpcId"].(string)
1575 | name, _ := arguments["name"].(string)
1576 |
1577 | if vpcId == "" {
1578 | return &mcp.CallToolResult{
1579 | IsError: true,
1580 | Content: []mcp.Content{
1581 | &mcp.TextContent{
1582 | Type: "text",
1583 | Text: "vpcId is required",
1584 | },
1585 | },
1586 | }, nil
1587 | }
1588 |
1589 | if name == "" {
1590 | name = "private-route-table"
1591 | }
1592 |
1593 | routeTableId := m.generateMockResourceId("rtb")
1594 |
1595 | response := map[string]interface{}{
1596 | "routeTableId": routeTableId,
1597 | "vpcId": vpcId,
1598 | "name": name,
1599 | "routeType": "private",
1600 | "resource": map[string]interface{}{
1601 | "id": routeTableId,
1602 | "type": "route_table",
1603 | "name": name,
1604 | },
1605 | }
1606 |
1607 | return m.createSuccessResponse(fmt.Sprintf("Private route table '%s' created successfully", name), response)
1608 | }
1609 |
1610 | func (m *MockMCPServer) mockAssociateRouteTable(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1611 | routeTableId, _ := arguments["routeTableId"].(string)
1612 | subnetId, _ := arguments["subnetId"].(string)
1613 |
1614 | if routeTableId == "" || subnetId == "" {
1615 | return &mcp.CallToolResult{
1616 | IsError: true,
1617 | Content: []mcp.Content{
1618 | &mcp.TextContent{
1619 | Type: "text",
1620 | Text: "routeTableId and subnetId are required",
1621 | },
1622 | },
1623 | }, nil
1624 | }
1625 |
1626 | associationId := m.generateMockResourceId("rtbassoc")
1627 |
1628 | response := map[string]interface{}{
1629 | "associationId": associationId,
1630 | "routeTableId": routeTableId,
1631 | "subnetId": subnetId,
1632 | "resource": map[string]interface{}{
1633 | "id": associationId,
1634 | "type": "route_table_association",
1635 | },
1636 | }
1637 |
1638 | return m.createSuccessResponse("Route table associated successfully", response)
1639 | }
1640 |
1641 | func (m *MockMCPServer) mockAddRoute(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1642 | routeTableId, _ := arguments["routeTableId"].(string)
1643 | destinationCidrBlock, _ := arguments["destinationCidrBlock"].(string)
1644 | gatewayId, _ := arguments["gatewayId"].(string)
1645 | natGatewayId, _ := arguments["natGatewayId"].(string)
1646 |
1647 | if routeTableId == "" || destinationCidrBlock == "" {
1648 | return &mcp.CallToolResult{
1649 | IsError: true,
1650 | Content: []mcp.Content{
1651 | &mcp.TextContent{
1652 | Type: "text",
1653 | Text: "routeTableId and destinationCidrBlock are required",
1654 | },
1655 | },
1656 | }, nil
1657 | }
1658 |
1659 | if gatewayId == "" && natGatewayId == "" {
1660 | return &mcp.CallToolResult{
1661 | IsError: true,
1662 | Content: []mcp.Content{
1663 | &mcp.TextContent{
1664 | Type: "text",
1665 | Text: "either gatewayId or natGatewayId must be specified",
1666 | },
1667 | },
1668 | }, nil
1669 | }
1670 |
1671 | response := map[string]interface{}{
1672 | "routeTableId": routeTableId,
1673 | "destinationCidrBlock": destinationCidrBlock,
1674 | "state": "active",
1675 | }
1676 |
1677 | if gatewayId != "" {
1678 | response["gatewayId"] = gatewayId
1679 | response["targetType"] = "gateway"
1680 | }
1681 | if natGatewayId != "" {
1682 | response["natGatewayId"] = natGatewayId
1683 | response["targetType"] = "nat-gateway"
1684 | }
1685 |
1686 | return m.createSuccessResponse("Route added successfully", response)
1687 | }
1688 |
1689 | // ==== Missing Security Group Mock Methods ====
1690 |
1691 | func (m *MockMCPServer) mockListSecurityGroups(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1692 | vpcId, _ := arguments["vpcId"].(string)
1693 |
1694 | securityGroups := []map[string]interface{}{
1695 | {
1696 | "groupId": "sg-default123",
1697 | "groupName": "default",
1698 | "description": "default VPC security group",
1699 | "vpcId": "vpc-default123",
1700 | "inboundRules": []map[string]interface{}{
1701 | {
1702 | "protocol": "-1",
1703 | "fromPort": -1,
1704 | "toPort": -1,
1705 | "source": "sg-default123",
1706 | },
1707 | },
1708 | "outboundRules": []map[string]interface{}{
1709 | {
1710 | "protocol": "-1",
1711 | "fromPort": -1,
1712 | "toPort": -1,
1713 | "destination": "0.0.0.0/0",
1714 | },
1715 | },
1716 | },
1717 | {
1718 | "groupId": "sg-web123",
1719 | "groupName": "web-tier",
1720 | "description": "Web tier security group",
1721 | "vpcId": "vpc-prod123",
1722 | "inboundRules": []map[string]interface{}{
1723 | {
1724 | "protocol": "tcp",
1725 | "fromPort": 80,
1726 | "toPort": 80,
1727 | "source": "0.0.0.0/0",
1728 | },
1729 | {
1730 | "protocol": "tcp",
1731 | "fromPort": 443,
1732 | "toPort": 443,
1733 | "source": "0.0.0.0/0",
1734 | },
1735 | },
1736 | },
1737 | }
1738 |
1739 | // Filter by VPC if specified
1740 | if vpcId != "" {
1741 | filteredGroups := []map[string]interface{}{}
1742 | for _, sg := range securityGroups {
1743 | if sg["vpcId"].(string) == vpcId {
1744 | filteredGroups = append(filteredGroups, sg)
1745 | }
1746 | }
1747 | securityGroups = filteredGroups
1748 | }
1749 |
1750 | response := map[string]interface{}{
1751 | "securityGroups": securityGroups,
1752 | "count": len(securityGroups),
1753 | }
1754 |
1755 | return m.createSuccessResponse(fmt.Sprintf("Found %d security groups", len(securityGroups)), response)
1756 | }
1757 |
1758 | func (m *MockMCPServer) mockAddSecurityGroupIngressRule(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1759 | groupId, _ := arguments["groupId"].(string)
1760 | protocol, _ := arguments["protocol"].(string)
1761 | fromPort, _ := arguments["fromPort"].(float64)
1762 | toPort, _ := arguments["toPort"].(float64)
1763 | cidrBlock, _ := arguments["cidrBlock"].(string)
1764 | sourceGroupId, _ := arguments["sourceGroupId"].(string)
1765 |
1766 | if groupId == "" {
1767 | return &mcp.CallToolResult{
1768 | IsError: true,
1769 | Content: []mcp.Content{
1770 | &mcp.TextContent{
1771 | Type: "text",
1772 | Text: "groupId is required",
1773 | },
1774 | },
1775 | }, nil
1776 | }
1777 |
1778 | if protocol == "" {
1779 | protocol = "tcp"
1780 | }
1781 |
1782 | rule := map[string]interface{}{
1783 | "protocol": protocol,
1784 | "fromPort": int(fromPort),
1785 | "toPort": int(toPort),
1786 | }
1787 |
1788 | if cidrBlock != "" {
1789 | rule["source"] = cidrBlock
1790 | } else if sourceGroupId != "" {
1791 | rule["source"] = sourceGroupId
1792 | } else {
1793 | rule["source"] = "0.0.0.0/0"
1794 | }
1795 |
1796 | response := map[string]interface{}{
1797 | "groupId": groupId,
1798 | "direction": "ingress",
1799 | "rule": rule,
1800 | }
1801 |
1802 | return m.createSuccessResponse("Ingress rule added successfully", response)
1803 | }
1804 |
1805 | func (m *MockMCPServer) mockAddSecurityGroupEgressRule(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1806 | groupId, _ := arguments["groupId"].(string)
1807 | protocol, _ := arguments["protocol"].(string)
1808 | fromPort, _ := arguments["fromPort"].(float64)
1809 | toPort, _ := arguments["toPort"].(float64)
1810 | cidrBlock, _ := arguments["cidrBlock"].(string)
1811 | destinationGroupId, _ := arguments["destinationGroupId"].(string)
1812 |
1813 | if groupId == "" {
1814 | return &mcp.CallToolResult{
1815 | IsError: true,
1816 | Content: []mcp.Content{
1817 | &mcp.TextContent{
1818 | Type: "text",
1819 | Text: "groupId is required",
1820 | },
1821 | },
1822 | }, nil
1823 | }
1824 |
1825 | if protocol == "" {
1826 | protocol = "tcp"
1827 | }
1828 |
1829 | rule := map[string]interface{}{
1830 | "protocol": protocol,
1831 | "fromPort": int(fromPort),
1832 | "toPort": int(toPort),
1833 | }
1834 |
1835 | if cidrBlock != "" {
1836 | rule["destination"] = cidrBlock
1837 | } else if destinationGroupId != "" {
1838 | rule["destination"] = destinationGroupId
1839 | } else {
1840 | rule["destination"] = "0.0.0.0/0"
1841 | }
1842 |
1843 | response := map[string]interface{}{
1844 | "groupId": groupId,
1845 | "direction": "egress",
1846 | "rule": rule,
1847 | }
1848 |
1849 | return m.createSuccessResponse("Egress rule added successfully", response)
1850 | }
1851 |
1852 | func (m *MockMCPServer) mockDeleteSecurityGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1853 | groupId, _ := arguments["groupId"].(string)
1854 |
1855 | if groupId == "" {
1856 | return &mcp.CallToolResult{
1857 | IsError: true,
1858 | Content: []mcp.Content{
1859 | &mcp.TextContent{
1860 | Type: "text",
1861 | Text: "groupId is required",
1862 | },
1863 | },
1864 | }, nil
1865 | }
1866 |
1867 | // Simulate validation - cannot delete default group
1868 | if strings.Contains(groupId, "default") {
1869 | return &mcp.CallToolResult{
1870 | IsError: true,
1871 | Content: []mcp.Content{
1872 | &mcp.TextContent{
1873 | Type: "text",
1874 | Text: "Cannot delete default security group",
1875 | },
1876 | },
1877 | }, nil
1878 | }
1879 |
1880 | response := map[string]interface{}{
1881 | "groupId": groupId,
1882 | "status": "deleted",
1883 | }
1884 |
1885 | return m.createSuccessResponse(fmt.Sprintf("Security group %s deleted successfully", groupId), response)
1886 | }
1887 |
1888 | // ==== Missing Auto Scaling Mock Methods ====
1889 |
1890 | func (m *MockMCPServer) mockCreateLaunchTemplate(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1891 | name, _ := arguments["name"].(string)
1892 | imageId, _ := arguments["imageId"].(string)
1893 | instanceType, _ := arguments["instanceType"].(string)
1894 | securityGroupIds, _ := arguments["securityGroupIds"].([]interface{})
1895 |
1896 | if name == "" {
1897 | name = "test-launch-template"
1898 | }
1899 | if imageId == "" {
1900 | imageId = "ami-latest123"
1901 | }
1902 | if instanceType == "" {
1903 | instanceType = "t3.micro"
1904 | }
1905 |
1906 | templateId := m.generateMockResourceId("lt")
1907 |
1908 | // Convert securityGroupIds to string slice
1909 | var sgIds []string
1910 | for _, sgId := range securityGroupIds {
1911 | if id, ok := sgId.(string); ok {
1912 | sgIds = append(sgIds, id)
1913 | }
1914 | }
1915 |
1916 | response := map[string]interface{}{
1917 | "launchTemplateId": templateId,
1918 | "name": name,
1919 | "imageId": imageId,
1920 | "instanceType": instanceType,
1921 | "securityGroupIds": sgIds,
1922 | "latestVersionNumber": 1,
1923 | "resource": map[string]interface{}{
1924 | "id": templateId,
1925 | "type": "launch_template",
1926 | "name": name,
1927 | },
1928 | }
1929 |
1930 | return m.createSuccessResponse(fmt.Sprintf("Launch template '%s' created successfully", name), response)
1931 | }
1932 |
1933 | func (m *MockMCPServer) mockCreateAutoScalingGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1934 | name, _ := arguments["name"].(string)
1935 | launchTemplateId, _ := arguments["launchTemplateId"].(string)
1936 | subnetIds, _ := arguments["subnetIds"].([]interface{})
1937 | minSize, _ := arguments["minSize"].(float64)
1938 | maxSize, _ := arguments["maxSize"].(float64)
1939 | desiredCapacity, _ := arguments["desiredCapacity"].(float64)
1940 |
1941 | if name == "" {
1942 | name = "test-asg"
1943 | }
1944 | // Be lenient for testing - generate a mock template ID if not provided
1945 | if launchTemplateId == "" {
1946 | launchTemplateId = m.generateMockResourceId("launch-template")
1947 | }
1948 |
1949 | asgArn := fmt.Sprintf("arn:aws:autoscaling:us-west-2:123456789012:autoScalingGroup:%s:autoScalingGroupName/%s",
1950 | m.generateMockResourceId("asg"), name)
1951 |
1952 | // Convert subnetIds to string slice
1953 | var subnets []string
1954 | for _, subnetId := range subnetIds {
1955 | if id, ok := subnetId.(string); ok {
1956 | subnets = append(subnets, id)
1957 | }
1958 | }
1959 |
1960 | response := map[string]interface{}{
1961 | "autoScalingGroupName": name,
1962 | "autoScalingGroupArn": asgArn,
1963 | "launchTemplateId": launchTemplateId,
1964 | "subnetIds": subnets,
1965 | "minSize": int(minSize),
1966 | "maxSize": int(maxSize),
1967 | "desiredCapacity": int(desiredCapacity),
1968 | "resource": map[string]interface{}{
1969 | "id": asgArn,
1970 | "type": "auto_scaling_group",
1971 | "name": name,
1972 | },
1973 | }
1974 |
1975 | return m.createSuccessResponse(fmt.Sprintf("Auto scaling group '%s' created successfully", name), response)
1976 | }
1977 |
1978 | func (m *MockMCPServer) mockListAutoScalingGroups(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
1979 | groups := []map[string]interface{}{
1980 | {
1981 | "autoScalingGroupName": "web-tier-asg",
1982 | "autoScalingGroupArn": "arn:aws:autoscaling:us-west-2:123456789012:autoScalingGroup:uuid:autoScalingGroupName/web-tier-asg",
1983 | "launchTemplateId": "lt-sample123",
1984 | "minSize": 1,
1985 | "maxSize": 3,
1986 | "desiredCapacity": 2,
1987 | "availabilityZones": []string{"us-west-2a", "us-west-2b"},
1988 | },
1989 | }
1990 |
1991 | response := map[string]interface{}{
1992 | "autoScalingGroups": groups,
1993 | "count": len(groups),
1994 | }
1995 |
1996 | return m.createSuccessResponse(fmt.Sprintf("Found %d auto scaling groups", len(groups)), response)
1997 | }
1998 |
1999 | func (m *MockMCPServer) mockListLaunchTemplates(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2000 | templates := []map[string]interface{}{
2001 | {
2002 | "launchTemplateId": "lt-sample123",
2003 | "name": "web-server-template",
2004 | "latestVersionNumber": 1,
2005 | "defaultVersionNumber": 1,
2006 | "imageId": "ami-latest123",
2007 | "instanceType": "t3.medium",
2008 | },
2009 | }
2010 |
2011 | response := map[string]interface{}{
2012 | "launchTemplates": templates,
2013 | "count": len(templates),
2014 | }
2015 |
2016 | return m.createSuccessResponse(fmt.Sprintf("Found %d launch templates", len(templates)), response)
2017 | }
2018 |
2019 | // ==== Missing Load Balancer Mock Methods ====
2020 |
2021 | func (m *MockMCPServer) mockListLoadBalancers(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2022 | loadBalancers := []map[string]interface{}{
2023 | {
2024 | "loadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/test-alb/1234567890123456",
2025 | "loadBalancerName": "test-alb",
2026 | "scheme": "internet-facing",
2027 | "vpcId": "vpc-prod123",
2028 | "type": "application",
2029 | "state": "active",
2030 | "dnsName": "test-alb-123456789.us-west-2.elb.amazonaws.com",
2031 | },
2032 | }
2033 |
2034 | response := map[string]interface{}{
2035 | "loadBalancers": loadBalancers,
2036 | "count": len(loadBalancers),
2037 | }
2038 |
2039 | return m.createSuccessResponse(fmt.Sprintf("Found %d load balancers", len(loadBalancers)), response)
2040 | }
2041 |
2042 | func (m *MockMCPServer) mockListTargetGroups(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2043 | targetGroups := []map[string]interface{}{
2044 | {
2045 | "targetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/web-servers/1234567890123456",
2046 | "targetGroupName": "web-servers",
2047 | "protocol": "HTTP",
2048 | "port": 80,
2049 | "vpcId": "vpc-prod123",
2050 | "targetType": "instance",
2051 | "healthCheckPath": "/health",
2052 | },
2053 | }
2054 |
2055 | response := map[string]interface{}{
2056 | "targetGroups": targetGroups,
2057 | "count": len(targetGroups),
2058 | }
2059 |
2060 | return m.createSuccessResponse(fmt.Sprintf("Found %d target groups", len(targetGroups)), response)
2061 | }
2062 |
2063 | func (m *MockMCPServer) mockRegisterTargets(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2064 | targetGroupArn, _ := arguments["targetGroupArn"].(string)
2065 | targets, _ := arguments["targets"].([]interface{})
2066 |
2067 | if targetGroupArn == "" {
2068 | return &mcp.CallToolResult{
2069 | IsError: true,
2070 | Content: []mcp.Content{
2071 | &mcp.TextContent{
2072 | Type: "text",
2073 | Text: "targetGroupArn is required",
2074 | },
2075 | },
2076 | }, nil
2077 | }
2078 |
2079 | var targetList []string
2080 | for _, target := range targets {
2081 | if targetStr, ok := target.(string); ok {
2082 | targetList = append(targetList, targetStr)
2083 | }
2084 | }
2085 |
2086 | response := map[string]interface{}{
2087 | "targetGroupArn": targetGroupArn,
2088 | "targets": targetList,
2089 | "status": "registered",
2090 | }
2091 |
2092 | return m.createSuccessResponse(fmt.Sprintf("Registered %d targets", len(targetList)), response)
2093 | }
2094 |
2095 | func (m *MockMCPServer) mockDeregisterTargets(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2096 | targetGroupArn, _ := arguments["targetGroupArn"].(string)
2097 | targets, _ := arguments["targets"].([]interface{})
2098 |
2099 | if targetGroupArn == "" {
2100 | return &mcp.CallToolResult{
2101 | IsError: true,
2102 | Content: []mcp.Content{
2103 | &mcp.TextContent{
2104 | Type: "text",
2105 | Text: "targetGroupArn is required",
2106 | },
2107 | },
2108 | }, nil
2109 | }
2110 |
2111 | var targetList []string
2112 | for _, target := range targets {
2113 | if targetStr, ok := target.(string); ok {
2114 | targetList = append(targetList, targetStr)
2115 | }
2116 | }
2117 |
2118 | response := map[string]interface{}{
2119 | "targetGroupArn": targetGroupArn,
2120 | "targets": targetList,
2121 | "status": "deregistered",
2122 | }
2123 |
2124 | return m.createSuccessResponse(fmt.Sprintf("Deregistered %d targets", len(targetList)), response)
2125 | }
2126 |
2127 | // ==== Missing RDS Mock Methods ====
2128 |
2129 | func (m *MockMCPServer) mockCreateDBSubnetGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2130 | name, _ := arguments["name"].(string)
2131 | description, _ := arguments["description"].(string)
2132 | subnetIds, _ := arguments["subnetIds"].([]interface{})
2133 |
2134 | if name == "" {
2135 | name = "test-db-subnet-group"
2136 | }
2137 | if description == "" {
2138 | description = "Test database subnet group"
2139 | }
2140 |
2141 | // Convert subnetIds to string slice
2142 | var subnets []string
2143 | for _, subnetId := range subnetIds {
2144 | if id, ok := subnetId.(string); ok {
2145 | subnets = append(subnets, id)
2146 | }
2147 | }
2148 |
2149 | if len(subnets) == 0 {
2150 | return &mcp.CallToolResult{
2151 | IsError: true,
2152 | Content: []mcp.Content{
2153 | &mcp.TextContent{
2154 | Type: "text",
2155 | Text: "At least one subnet ID is required",
2156 | },
2157 | },
2158 | }, nil
2159 | }
2160 |
2161 | response := map[string]interface{}{
2162 | "dbSubnetGroupName": name,
2163 | "description": description,
2164 | "subnetIds": subnets,
2165 | "vpcId": "vpc-prod123",
2166 | "dbSubnetGroupStatus": "Complete",
2167 | "resource": map[string]interface{}{
2168 | "id": name,
2169 | "type": "db_subnet_group",
2170 | "name": name,
2171 | },
2172 | }
2173 |
2174 | return m.createSuccessResponse(fmt.Sprintf("DB subnet group '%s' created successfully", name), response)
2175 | }
2176 |
2177 | func (m *MockMCPServer) mockCreateDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2178 | dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
2179 | dbInstanceClass, _ := arguments["dbInstanceClass"].(string)
2180 | engine, _ := arguments["engine"].(string)
2181 | masterUsername, _ := arguments["masterUsername"].(string)
2182 | dbSubnetGroupName, _ := arguments["dbSubnetGroupName"].(string)
2183 | allocatedStorage, _ := arguments["allocatedStorage"].(float64)
2184 |
2185 | if dbInstanceIdentifier == "" {
2186 | dbInstanceIdentifier = "test-db-instance"
2187 | }
2188 | if dbInstanceClass == "" {
2189 | dbInstanceClass = "db.t3.micro"
2190 | }
2191 | if engine == "" {
2192 | engine = "mysql"
2193 | }
2194 | if masterUsername == "" {
2195 | masterUsername = "admin"
2196 | }
2197 | if allocatedStorage == 0 {
2198 | allocatedStorage = 20
2199 | }
2200 |
2201 | endpoint := fmt.Sprintf("%s.cluster-xyz.us-west-2.rds.amazonaws.com", dbInstanceIdentifier)
2202 | dbArn := fmt.Sprintf("arn:aws:rds:us-west-2:123456789012:db:%s", dbInstanceIdentifier)
2203 |
2204 | response := map[string]interface{}{
2205 | "dbInstanceIdentifier": dbInstanceIdentifier,
2206 | "dbInstanceClass": dbInstanceClass,
2207 | "engine": engine,
2208 | "dbInstanceStatus": "available",
2209 | "masterUsername": masterUsername,
2210 | "allocatedStorage": int(allocatedStorage),
2211 | "dbSubnetGroupName": dbSubnetGroupName,
2212 | "endpoint": endpoint,
2213 | "port": 3306,
2214 | "dbInstanceArn": dbArn,
2215 | "resource": map[string]interface{}{
2216 | "id": dbInstanceIdentifier,
2217 | "type": "db_instance",
2218 | "name": dbInstanceIdentifier,
2219 | },
2220 | }
2221 |
2222 | return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' created successfully", dbInstanceIdentifier), response)
2223 | }
2224 |
2225 | func (m *MockMCPServer) mockStartDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2226 | dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
2227 |
2228 | if dbInstanceIdentifier == "" {
2229 | return &mcp.CallToolResult{
2230 | IsError: true,
2231 | Content: []mcp.Content{
2232 | &mcp.TextContent{
2233 | Type: "text",
2234 | Text: "dbInstanceIdentifier is required",
2235 | },
2236 | },
2237 | }, nil
2238 | }
2239 |
2240 | response := map[string]interface{}{
2241 | "dbInstanceIdentifier": dbInstanceIdentifier,
2242 | "previousStatus": "stopped",
2243 | "currentStatus": "starting",
2244 | "resource": map[string]interface{}{
2245 | "id": dbInstanceIdentifier,
2246 | "type": "db_instance",
2247 | },
2248 | }
2249 |
2250 | return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' started successfully", dbInstanceIdentifier), response)
2251 | }
2252 |
2253 | func (m *MockMCPServer) mockStopDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2254 | dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
2255 |
2256 | if dbInstanceIdentifier == "" {
2257 | return &mcp.CallToolResult{
2258 | IsError: true,
2259 | Content: []mcp.Content{
2260 | &mcp.TextContent{
2261 | Type: "text",
2262 | Text: "dbInstanceIdentifier is required",
2263 | },
2264 | },
2265 | }, nil
2266 | }
2267 |
2268 | response := map[string]interface{}{
2269 | "dbInstanceIdentifier": dbInstanceIdentifier,
2270 | "previousStatus": "available",
2271 | "currentStatus": "stopping",
2272 | "resource": map[string]interface{}{
2273 | "id": dbInstanceIdentifier,
2274 | "type": "db_instance",
2275 | },
2276 | }
2277 |
2278 | return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' stopped successfully", dbInstanceIdentifier), response)
2279 | }
2280 |
2281 | func (m *MockMCPServer) mockDeleteDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2282 | dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
2283 | skipFinalSnapshot, _ := arguments["skipFinalSnapshot"].(bool)
2284 |
2285 | if dbInstanceIdentifier == "" {
2286 | return &mcp.CallToolResult{
2287 | IsError: true,
2288 | Content: []mcp.Content{
2289 | &mcp.TextContent{
2290 | Type: "text",
2291 | Text: "dbInstanceIdentifier is required",
2292 | },
2293 | },
2294 | }, nil
2295 | }
2296 |
2297 | response := map[string]interface{}{
2298 | "dbInstanceIdentifier": dbInstanceIdentifier,
2299 | "currentStatus": "deleting",
2300 | "skipFinalSnapshot": skipFinalSnapshot,
2301 | "resource": map[string]interface{}{
2302 | "id": dbInstanceIdentifier,
2303 | "type": "db_instance",
2304 | },
2305 | }
2306 |
2307 | return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' deletion initiated", dbInstanceIdentifier), response)
2308 | }
2309 |
2310 | func (m *MockMCPServer) mockCreateDBSnapshot(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2311 | dbSnapshotIdentifier, _ := arguments["dbSnapshotIdentifier"].(string)
2312 | dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
2313 |
2314 | if dbSnapshotIdentifier == "" || dbInstanceIdentifier == "" {
2315 | return &mcp.CallToolResult{
2316 | IsError: true,
2317 | Content: []mcp.Content{
2318 | &mcp.TextContent{
2319 | Type: "text",
2320 | Text: "Both dbSnapshotIdentifier and dbInstanceIdentifier are required",
2321 | },
2322 | },
2323 | }, nil
2324 | }
2325 |
2326 | snapshotArn := fmt.Sprintf("arn:aws:rds:us-west-2:123456789012:snapshot:%s", dbSnapshotIdentifier)
2327 |
2328 | response := map[string]interface{}{
2329 | "dbSnapshotIdentifier": dbSnapshotIdentifier,
2330 | "dbInstanceIdentifier": dbInstanceIdentifier,
2331 | "status": "creating",
2332 | "snapshotType": "manual",
2333 | "dbSnapshotArn": snapshotArn,
2334 | "resource": map[string]interface{}{
2335 | "id": dbSnapshotIdentifier,
2336 | "type": "db_snapshot",
2337 | "name": dbSnapshotIdentifier,
2338 | },
2339 | }
2340 |
2341 | return m.createSuccessResponse(fmt.Sprintf("DB snapshot '%s' creation initiated", dbSnapshotIdentifier), response)
2342 | }
2343 |
2344 | func (m *MockMCPServer) mockListDBInstances(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2345 | instances := []map[string]interface{}{
2346 | {
2347 | "dbInstanceIdentifier": "production-mysql",
2348 | "dbInstanceClass": "db.t3.medium",
2349 | "engine": "mysql",
2350 | "dbInstanceStatus": "available",
2351 | "allocatedStorage": 100,
2352 | "endpoint": "production-mysql.cluster-xyz.us-west-2.rds.amazonaws.com",
2353 | "port": 3306,
2354 | },
2355 | {
2356 | "dbInstanceIdentifier": "test-postgres",
2357 | "dbInstanceClass": "db.t3.micro",
2358 | "engine": "postgres",
2359 | "dbInstanceStatus": "available",
2360 | "allocatedStorage": 20,
2361 | "endpoint": "test-postgres.cluster-abc.us-west-2.rds.amazonaws.com",
2362 | "port": 5432,
2363 | },
2364 | }
2365 |
2366 | response := map[string]interface{}{
2367 | "dbInstances": instances,
2368 | "count": len(instances),
2369 | }
2370 |
2371 | return m.createSuccessResponse(fmt.Sprintf("Found %d DB instances", len(instances)), response)
2372 | }
2373 |
2374 | func (m *MockMCPServer) mockListDBSnapshots(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2375 | snapshots := []map[string]interface{}{
2376 | {
2377 | "dbSnapshotIdentifier": "production-mysql-snapshot-2023-10-01",
2378 | "dbInstanceIdentifier": "production-mysql",
2379 | "status": "available",
2380 | "snapshotType": "manual",
2381 | "allocatedStorage": 100,
2382 | },
2383 | }
2384 |
2385 | response := map[string]interface{}{
2386 | "dbSnapshots": snapshots,
2387 | "count": len(snapshots),
2388 | }
2389 |
2390 | return m.createSuccessResponse(fmt.Sprintf("Found %d DB snapshots", len(snapshots)), response)
2391 | }
2392 |
2393 | // ==== Missing State Management Mock Methods ====
2394 |
2395 | func (m *MockMCPServer) mockAnalyzeInfrastructureState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2396 | includeMetrics, _ := arguments["includeMetrics"].(bool)
2397 |
2398 | analysis := map[string]interface{}{
2399 | "totalResources": 15,
2400 | "resourcesByType": map[string]int{
2401 | "vpc": 2,
2402 | "subnet": 4,
2403 | "ec2_instance": 3,
2404 | "security_group": 3,
2405 | "load_balancer": 1,
2406 | "target_group": 1,
2407 | "db_instance": 1,
2408 | },
2409 | "healthStatus": "healthy",
2410 | "warnings": []string{
2411 | "Security group sg-web123 has overly permissive ingress rules",
2412 | },
2413 | "recommendations": []string{
2414 | "Consider enabling VPC Flow Logs for better network monitoring",
2415 | "Review security group rules for least privilege access",
2416 | },
2417 | }
2418 |
2419 | if includeMetrics {
2420 | analysis["metrics"] = map[string]interface{}{
2421 | "averageResourceAge": "30 days",
2422 | "resourceUtilization": "75%",
2423 | "complianceScore": 85,
2424 | }
2425 | }
2426 |
2427 | response := map[string]interface{}{
2428 | "analysis": analysis,
2429 | }
2430 |
2431 | return m.createSuccessResponse("Infrastructure state analyzed successfully", response)
2432 | }
2433 |
2434 | func (m *MockMCPServer) mockVisualizeDependencyGraph(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2435 | format, _ := arguments["format"].(string)
2436 | if format == "" {
2437 | format = "mermaid"
2438 | }
2439 |
2440 | var visualization string
2441 | if format == "mermaid" {
2442 | visualization = `graph TD
2443 | VPC[vpc-prod123] --> Subnet1[subnet-web-1]
2444 | VPC --> Subnet2[subnet-web-2]
2445 | Subnet1 --> ALB[test-alb]
2446 | Subnet2 --> ALB
2447 | ALB --> TG[web-servers]
2448 | TG --> EC2_1[i-web-1]
2449 | TG --> EC2_2[i-web-2]
2450 | VPC --> SG[sg-web123]
2451 | SG --> EC2_1
2452 | SG --> EC2_2`
2453 | } else {
2454 | visualization = "Dependency graph visualization not available for format: " + format
2455 | }
2456 |
2457 | response := map[string]interface{}{
2458 | "format": format,
2459 | "visualization": visualization,
2460 | "nodeCount": 8,
2461 | "edgeCount": 10,
2462 | }
2463 |
2464 | return m.createSuccessResponse("Dependency graph generated successfully", response)
2465 | }
2466 |
2467 | func (m *MockMCPServer) mockDetectInfrastructureConflicts(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2468 | conflicts := []map[string]interface{}{
2469 | {
2470 | "type": "security_group_overlap",
2471 | "severity": "medium",
2472 | "resources": []string{"sg-web123", "sg-app123"},
2473 | "description": "Security groups have overlapping port ranges that may cause confusion",
2474 | "recommendation": "Review and consolidate security group rules",
2475 | },
2476 | {
2477 | "type": "subnet_cidr_conflict",
2478 | "severity": "low",
2479 | "resources": []string{"subnet-web-1", "subnet-db-1"},
2480 | "description": "Subnets are in different availability zones but have similar naming",
2481 | "recommendation": "Use consistent naming convention for subnets",
2482 | },
2483 | }
2484 |
2485 | response := map[string]interface{}{
2486 | "conflicts": conflicts,
2487 | "conflictCount": len(conflicts),
2488 | "severityCounts": map[string]int{
2489 | "high": 0,
2490 | "medium": 1,
2491 | "low": 1,
2492 | },
2493 | }
2494 |
2495 | return m.createSuccessResponse(fmt.Sprintf("Found %d infrastructure conflicts", len(conflicts)), response)
2496 | }
2497 |
2498 | func (m *MockMCPServer) mockPlanInfrastructureDeployment(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2499 | dryRun, _ := arguments["dryRun"].(bool)
2500 |
2501 | plan := map[string]interface{}{
2502 | "totalSteps": 8,
2503 | "estimatedDuration": "15 minutes",
2504 | "steps": []map[string]interface{}{
2505 | {
2506 | "step": 1,
2507 | "action": "create",
2508 | "resourceType": "vpc",
2509 | "resourceName": "production-vpc",
2510 | "dependencies": []string{},
2511 | },
2512 | {
2513 | "step": 2,
2514 | "action": "create",
2515 | "resourceType": "subnet",
2516 | "resourceName": "web-subnet-1",
2517 | "dependencies": []string{"production-vpc"},
2518 | },
2519 | {
2520 | "step": 3,
2521 | "action": "create",
2522 | "resourceType": "subnet",
2523 | "resourceName": "web-subnet-2",
2524 | "dependencies": []string{"production-vpc"},
2525 | },
2526 | {
2527 | "step": 4,
2528 | "action": "create",
2529 | "resourceType": "security_group",
2530 | "resourceName": "web-sg",
2531 | "dependencies": []string{"production-vpc"},
2532 | },
2533 | {
2534 | "step": 5,
2535 | "action": "create",
2536 | "resourceType": "load_balancer",
2537 | "resourceName": "web-alb",
2538 | "dependencies": []string{"web-subnet-1", "web-subnet-2", "web-sg"},
2539 | },
2540 | },
2541 | "warnings": []string{
2542 | "This deployment will create resources that incur AWS charges",
2543 | },
2544 | }
2545 |
2546 | if dryRun {
2547 | plan["mode"] = "dry-run"
2548 | plan["status"] = "planned"
2549 | } else {
2550 | plan["mode"] = "execute"
2551 | plan["status"] = "ready"
2552 | }
2553 |
2554 | response := map[string]interface{}{
2555 | "deploymentPlan": plan,
2556 | }
2557 |
2558 | return m.createSuccessResponse("Deployment plan generated successfully", response)
2559 | }
2560 |
2561 | func (m *MockMCPServer) mockAddResourceToState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2562 | resourceId, _ := arguments["resource_id"].(string)
2563 | resourceType, _ := arguments["resource_type"].(string)
2564 | resourceData, _ := arguments["properties"].(map[string]interface{})
2565 |
2566 | if resourceId == "" || resourceType == "" {
2567 | return &mcp.CallToolResult{
2568 | IsError: true,
2569 | Content: []mcp.Content{
2570 | &mcp.TextContent{
2571 | Type: "text",
2572 | Text: "resourceId and resourceType are required",
2573 | },
2574 | },
2575 | }, nil
2576 | }
2577 |
2578 | // Add to mock state manager
2579 | resource := &types.AWSResource{
2580 | ID: resourceId,
2581 | Type: resourceType,
2582 | Details: resourceData,
2583 | }
2584 |
2585 | m.resources[resourceId] = resource
2586 |
2587 | response := map[string]interface{}{
2588 | "resourceId": resourceId,
2589 | "resourceType": resourceType,
2590 | "status": "added_to_state",
2591 | "resource": resource,
2592 | }
2593 |
2594 | return m.createSuccessResponse(fmt.Sprintf("Resource %s added to state successfully", resourceId), response)
2595 | }
2596 |
2597 | func (m *MockMCPServer) mockSaveState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
2598 | filePath, _ := arguments["filePath"].(string)
2599 | if filePath == "" {
2600 | filePath = "infrastructure-state-test.json"
2601 | }
2602 |
2603 | resourceCount := len(m.resources)
2604 |
2605 | response := map[string]interface{}{
2606 | "filePath": filePath,
2607 | "resourceCount": resourceCount,
2608 | "timestamp": "2023-10-20T10:30:00Z",
2609 | "status": "saved",
2610 | }
2611 |
2612 | return m.createSuccessResponse(fmt.Sprintf("State saved to %s with %d resources", filePath, resourceCount), response)
2613 | }
2614 |
2615 | // ==== Mock Configuration Methods ====
2616 |
2617 | // SetError configures error simulation for a specific tool
2618 | func (m *MockMCPServer) SetError(toolName string, err error) {
2619 | m.mutex.Lock()
2620 | defer m.mutex.Unlock()
2621 | m.simulateErrors[toolName] = err
2622 | }
2623 |
```