This is page 111 of 115. Use http://codebase.md/versuscontrol/ai-infrastructure-agent?lines=false&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.anthropic.yaml.example
├── config.bedrock.yaml.example
├── config.gemini.yaml.example
├── config.ollama.yaml.example
├── config.openai.yaml.example
├── config.yaml
├── Dockerfile
├── docs
│ ├── _sidebar.md
│ ├── .nojekyll
│ ├── api-key-setup
│ │ ├── anthropic-api-setup.md
│ │ ├── aws-bedrock-nova-setup.md
│ │ ├── gemini-api-setup.md
│ │ ├── ollama-setup.md
│ │ └── openai-api-setup.md
│ ├── architecture
│ │ └── architecture-overview.md
│ ├── CNAME
│ ├── docs.html
│ ├── examples
│ │ ├── working-with-ec2-instance.md
│ │ └── working-with-vpc.md
│ ├── getting-started.md
│ ├── images
│ │ ├── advanced-demo.svg
│ │ ├── ai-analysis-planning.png
│ │ ├── ai-execute-planning.png
│ │ ├── ai-infrastructure-agent.svg
│ │ ├── ai-infrastructure-state.png
│ │ ├── core-components.svg
│ │ ├── ec2-00.png
│ │ ├── ec2-01.png
│ │ ├── ec2-02.png
│ │ ├── ec2-03.png
│ │ ├── ec2-04.png
│ │ ├── ec2-05.png
│ │ ├── ec2-06.png
│ │ ├── ec2-07.png
│ │ ├── pattern.879b8d77.svg
│ │ ├── simple-demo.png
│ │ ├── vpc-00.png
│ │ ├── vpc-01.png
│ │ ├── vpc-02.png
│ │ ├── vpc-03.png
│ │ ├── vpc-04.png
│ │ ├── vpc-05.png
│ │ ├── vpc-06.png
│ │ ├── vpc-07.png
│ │ ├── vpc-08.png
│ │ ├── vpc-09.png
│ │ ├── vpc-10.png
│ │ ├── vpc-11.png
│ │ ├── vpc-architecture.svg
│ │ └── web-dashboard.svg
│ ├── index.html
│ ├── installation.md
│ └── README.md
├── go.mod
├── go.sum
├── internal
│ ├── config
│ │ ├── config.go
│ │ └── loader.go
│ └── logging
│ └── logger.go
├── LICENSE
├── pkg
│ ├── adapters
│ │ ├── alb.go
│ │ ├── asg.go
│ │ ├── base.go
│ │ ├── ec2.go
│ │ ├── keypair.go
│ │ ├── rds.go
│ │ ├── security_group.go
│ │ └── vpc.go
│ ├── agent
│ │ ├── agent_capability_extractors.go
│ │ ├── agent_dependency_resolver.go
│ │ ├── agent_factory.go
│ │ ├── agent_json_processing.go
│ │ ├── agent_plan_executor.go
│ │ ├── agent_request_processor.go
│ │ ├── agent_resource_correlation.go
│ │ ├── agent_state.go
│ │ ├── agent_test.go
│ │ ├── agent_utility_helpers.go
│ │ ├── mcp_communication.go
│ │ ├── mocks
│ │ │ ├── aws_client_mock.go
│ │ │ ├── helpers.go
│ │ │ ├── mcp_integration_test.go
│ │ │ ├── mcp_server_mock.go
│ │ │ ├── state_manager_mock.go
│ │ │ └── validation.go
│ │ ├── react_plan_recovery_engine.go
│ │ ├── react_plan_utility_helpers.go
│ │ ├── resources
│ │ │ ├── field_resolver.go
│ │ │ ├── id_extractor.go
│ │ │ └── pattern_matcher.go
│ │ └── types.go
│ ├── api
│ │ ├── decision_storage.go
│ │ ├── handlers_agent.go
│ │ ├── handlers_discovery.go
│ │ ├── handlers_state.go
│ │ ├── handlers_system.go
│ │ ├── recovery_coordinator.go
│ │ ├── server.go
│ │ ├── types.go
│ │ ├── websocket_messages.go
│ │ └── websocket.go
│ ├── aws
│ │ ├── alb.go
│ │ ├── asg.go
│ │ ├── client.go
│ │ ├── ec2.go
│ │ ├── params.go
│ │ ├── rds.go
│ │ ├── security_group.go
│ │ └── vpc.go
│ ├── conflict
│ │ └── resolver.go
│ ├── discovery
│ │ └── scanner.go
│ ├── graph
│ │ ├── analyzer.go
│ │ └── manager.go
│ ├── interfaces
│ │ ├── aws_resource.go
│ │ ├── mcp_tool.go
│ │ └── state_management.go
│ ├── mcp
│ │ ├── resource_definitions.go
│ │ ├── resource_registry.go
│ │ ├── server_integration.go
│ │ ├── server.go
│ │ └── tool_manager.go
│ ├── state
│ │ └── manager.go
│ ├── tools
│ │ ├── alb_tools.go
│ │ ├── ami_tools.go
│ │ ├── asg_tools.go
│ │ ├── ec2_tools.go
│ │ ├── factory.go
│ │ ├── helpers.go
│ │ ├── keypair_tools.go
│ │ ├── networking_tools.go
│ │ ├── rds_tools.go
│ │ ├── registry.go
│ │ ├── security_group_tools.go
│ │ ├── state_tools.go
│ │ ├── vpc_tools.go
│ │ └── zone_tools.go
│ ├── types
│ │ └── mcp.go
│ └── utilities
│ └── helpers.go
├── README.md
├── scripts
│ ├── install.sh
│ └── run-web-ui.sh
├── settings
│ ├── field-mappings-enhanced.yaml
│ ├── resource-extraction-enhanced.yaml
│ ├── resource-patterns-enhanced.yaml
│ └── templates
│ ├── decision-plan-prompt-optimized.txt
│ ├── recovery-prompt-optimized.txt
│ └── tools-execution-context-optimized.txt
└── web
└── build
├── ai-infrastructure-agent.svg
├── asset-manifest.json
├── aws-service-icons
│ ├── .DS_Store
│ ├── analytics
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Athena_16.png
│ │ │ ├── Arch_Amazon-Athena_16.svg
│ │ │ ├── Arch_Amazon-CloudSearch_16.png
│ │ │ ├── Arch_Amazon-CloudSearch_16.svg
│ │ │ ├── Arch_Amazon-Data-Firehose_16.png
│ │ │ ├── Arch_Amazon-Data-Firehose_16.svg
│ │ │ ├── Arch_Amazon-DataZone_16.png
│ │ │ ├── Arch_Amazon-DataZone_16.svg
│ │ │ ├── Arch_Amazon-EMR_16.png
│ │ │ ├── Arch_Amazon-EMR_16.svg
│ │ │ ├── Arch_Amazon-FinSpace_16.png
│ │ │ ├── Arch_Amazon-FinSpace_16.svg
│ │ │ ├── Arch_Amazon-Kinesis_16.png
│ │ │ ├── Arch_Amazon-Kinesis_16.svg
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_16.png
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_16.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_16.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_16.svg
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_16.png
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_16.svg
│ │ │ ├── Arch_Amazon-OpenSearch-Service_16.png
│ │ │ ├── Arch_Amazon-OpenSearch-Service_16.svg
│ │ │ ├── Arch_Amazon-QuickSight_16.png
│ │ │ ├── Arch_Amazon-QuickSight_16.svg
│ │ │ ├── Arch_Amazon-Redshift_16.png
│ │ │ ├── Arch_Amazon-Redshift_16.svg
│ │ │ ├── Arch_Amazon-SageMaker_16.png
│ │ │ ├── Arch_Amazon-SageMaker_16.svg
│ │ │ ├── Arch_AWS-Clean-Rooms_16.png
│ │ │ ├── Arch_AWS-Clean-Rooms_16.svg
│ │ │ ├── Arch_AWS-Data-Exchange_16.png
│ │ │ ├── Arch_AWS-Data-Exchange_16.svg
│ │ │ ├── Arch_AWS-Entity-Resolution_16.png
│ │ │ ├── Arch_AWS-Entity-Resolution_16.svg
│ │ │ ├── Arch_AWS-Glue_16.png
│ │ │ ├── Arch_AWS-Glue_16.svg
│ │ │ ├── Arch_AWS-Glue-DataBrew_16.png
│ │ │ ├── Arch_AWS-Glue-DataBrew_16.svg
│ │ │ ├── Arch_AWS-Lake-Formation_16.png
│ │ │ └── Arch_AWS-Lake-Formation_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Athena_32.png
│ │ │ ├── Arch_Amazon-Athena_32.svg
│ │ │ ├── Arch_Amazon-CloudSearch_32.png
│ │ │ ├── Arch_Amazon-CloudSearch_32.svg
│ │ │ ├── Arch_Amazon-Data-Firehose_32.png
│ │ │ ├── Arch_Amazon-Data-Firehose_32.svg
│ │ │ ├── Arch_Amazon-DataZone_32.png
│ │ │ ├── Arch_Amazon-DataZone_32.svg
│ │ │ ├── Arch_Amazon-EMR_32.png
│ │ │ ├── Arch_Amazon-EMR_32.svg
│ │ │ ├── Arch_Amazon-FinSpace_32.png
│ │ │ ├── Arch_Amazon-FinSpace_32.svg
│ │ │ ├── Arch_Amazon-Kinesis_32.png
│ │ │ ├── Arch_Amazon-Kinesis_32.svg
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_32.png
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_32.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_32.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_32.svg
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_32.png
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_32.svg
│ │ │ ├── Arch_Amazon-OpenSearch-Service_32.png
│ │ │ ├── Arch_Amazon-OpenSearch-Service_32.svg
│ │ │ ├── Arch_Amazon-QuickSight_32.png
│ │ │ ├── Arch_Amazon-QuickSight_32.svg
│ │ │ ├── Arch_Amazon-Redshift_32.png
│ │ │ ├── Arch_Amazon-Redshift_32.svg
│ │ │ ├── Arch_Amazon-SageMaker_32.png
│ │ │ ├── Arch_Amazon-SageMaker_32.svg
│ │ │ ├── Arch_AWS-Clean-Rooms_32.png
│ │ │ ├── Arch_AWS-Clean-Rooms_32.svg
│ │ │ ├── Arch_AWS-Data-Exchange_32.png
│ │ │ ├── Arch_AWS-Data-Exchange_32.svg
│ │ │ ├── Arch_AWS-Entity-Resolution_32.png
│ │ │ ├── Arch_AWS-Entity-Resolution_32.svg
│ │ │ ├── Arch_AWS-Glue_32.png
│ │ │ ├── Arch_AWS-Glue_32.svg
│ │ │ ├── Arch_AWS-Glue-DataBrew_32.png
│ │ │ ├── Arch_AWS-Glue-DataBrew_32.svg
│ │ │ ├── Arch_AWS-Lake-Formation_32.png
│ │ │ └── Arch_AWS-Lake-Formation_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Athena_48.png
│ │ │ ├── Arch_Amazon-Athena_48.svg
│ │ │ ├── Arch_Amazon-CloudSearch_48.png
│ │ │ ├── Arch_Amazon-CloudSearch_48.svg
│ │ │ ├── Arch_Amazon-Data-Firehose_48.png
│ │ │ ├── Arch_Amazon-Data-Firehose_48.svg
│ │ │ ├── Arch_Amazon-DataZone_48.png
│ │ │ ├── Arch_Amazon-DataZone_48.svg
│ │ │ ├── Arch_Amazon-EMR_48.png
│ │ │ ├── Arch_Amazon-EMR_48.svg
│ │ │ ├── Arch_Amazon-FinSpace_48.png
│ │ │ ├── Arch_Amazon-FinSpace_48.svg
│ │ │ ├── Arch_Amazon-Kinesis_48.png
│ │ │ ├── Arch_Amazon-Kinesis_48.svg
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_48.png
│ │ │ ├── Arch_Amazon-Kinesis-Data-Streams_48.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_48.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_48.svg
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_48.png
│ │ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_48.svg
│ │ │ ├── Arch_Amazon-OpenSearch-Service_48.png
│ │ │ ├── Arch_Amazon-OpenSearch-Service_48.svg
│ │ │ ├── Arch_Amazon-QuickSight_48.png
│ │ │ ├── Arch_Amazon-QuickSight_48.svg
│ │ │ ├── Arch_Amazon-Redshift_48.png
│ │ │ ├── Arch_Amazon-Redshift_48.svg
│ │ │ ├── Arch_Amazon-SageMaker_48.png
│ │ │ ├── Arch_Amazon-SageMaker_48.svg
│ │ │ ├── Arch_AWS-Clean-Rooms_48.png
│ │ │ ├── Arch_AWS-Clean-Rooms_48.svg
│ │ │ ├── Arch_AWS-Data-Exchange_48.png
│ │ │ ├── Arch_AWS-Data-Exchange_48.svg
│ │ │ ├── Arch_AWS-Entity-Resolution_48.png
│ │ │ ├── Arch_AWS-Entity-Resolution_48.svg
│ │ │ ├── Arch_AWS-Glue_48.png
│ │ │ ├── Arch_AWS-Glue_48.svg
│ │ │ ├── Arch_AWS-Glue-DataBrew_48.png
│ │ │ ├── Arch_AWS-Glue-DataBrew_48.svg
│ │ │ ├── Arch_AWS-Lake-Formation_48.png
│ │ │ └── Arch_AWS-Lake-Formation_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Athena_64.png
│ │ ├── Arch_Amazon-Athena_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CloudSearch_64.png
│ │ ├── Arch_Amazon-CloudSearch_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Data-Firehose_64.png
│ │ ├── Arch_Amazon-Data-Firehose_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DataZone_64.png
│ │ ├── Arch_Amazon-DataZone_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EMR_64.png
│ │ ├── Arch_Amazon-EMR_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-FinSpace_64.png
│ │ ├── Arch_Amazon-FinSpace_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis_64.png
│ │ ├── Arch_Amazon-Kinesis_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis-Data-Streams_64.png
│ │ ├── Arch_Amazon-Kinesis-Data-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.png
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_64.png
│ │ ├── Arch_Amazon-Managed-Service-for-Apache-Flink_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_64.png
│ │ ├── Arch_Amazon-Managed-Streaming-for-Apache-Kafka_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-OpenSearch-Service_64.png
│ │ ├── Arch_Amazon-OpenSearch-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-QuickSight_64.png
│ │ ├── Arch_Amazon-QuickSight_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Redshift_64.png
│ │ ├── Arch_Amazon-Redshift_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker_64.png
│ │ ├── Arch_Amazon-SageMaker_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Clean-Rooms_64.png
│ │ ├── Arch_AWS-Clean-Rooms_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Data-Exchange_64.png
│ │ ├── Arch_AWS-Data-Exchange_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Entity-Resolution_64.png
│ │ ├── Arch_AWS-Entity-Resolution_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Glue_64.png
│ │ ├── Arch_AWS-Glue_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Glue-DataBrew_64.png
│ │ ├── Arch_AWS-Glue-DataBrew_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Lake-Formation_64.png
│ │ ├── Arch_AWS-Lake-Formation_64.svg
│ │ └── [email protected]
│ ├── app-integration
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppFlow_16.png
│ │ │ ├── Arch_Amazon-AppFlow_16.svg
│ │ │ ├── Arch_Amazon-EventBridge_16.png
│ │ │ ├── Arch_Amazon-EventBridge_16.svg
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_16.png
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_16.svg
│ │ │ ├── Arch_Amazon-MQ_16.png
│ │ │ ├── Arch_Amazon-MQ_16.svg
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_16.png
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_16.svg
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_16.png
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_16.svg
│ │ │ ├── Arch_AWS-AppSync_16.png
│ │ │ ├── Arch_AWS-AppSync_16.svg
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_16.png
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_16.svg
│ │ │ ├── Arch_AWS-Express-Workflows_16.png
│ │ │ ├── Arch_AWS-Express-Workflows_16.svg
│ │ │ ├── Arch_AWS-Step-Functions_16.png
│ │ │ └── Arch_AWS-Step-Functions_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppFlow_32.png
│ │ │ ├── Arch_Amazon-AppFlow_32.svg
│ │ │ ├── Arch_Amazon-EventBridge_32.png
│ │ │ ├── Arch_Amazon-EventBridge_32.svg
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_32.png
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_32.svg
│ │ │ ├── Arch_Amazon-MQ_32.png
│ │ │ ├── Arch_Amazon-MQ_32.svg
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_32.png
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_32.svg
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_32.png
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_32.svg
│ │ │ ├── Arch_AWS-AppSync_32.png
│ │ │ ├── Arch_AWS-AppSync_32.svg
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_32.png
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_32.svg
│ │ │ ├── Arch_AWS-Express-Workflows_32.png
│ │ │ ├── Arch_AWS-Express-Workflows_32.svg
│ │ │ ├── Arch_AWS-Step-Functions_32.png
│ │ │ └── Arch_AWS-Step-Functions_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppFlow_48.png
│ │ │ ├── Arch_Amazon-AppFlow_48.svg
│ │ │ ├── Arch_Amazon-EventBridge_48.png
│ │ │ ├── Arch_Amazon-EventBridge_48.svg
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_48.png
│ │ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_48.svg
│ │ │ ├── Arch_Amazon-MQ_48.png
│ │ │ ├── Arch_Amazon-MQ_48.svg
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_48.png
│ │ │ ├── Arch_Amazon-Simple-Notification-Service_48.svg
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_48.png
│ │ │ ├── Arch_Amazon-Simple-Queue-Service_48.svg
│ │ │ ├── Arch_AWS-AppSync_48.png
│ │ │ ├── Arch_AWS-AppSync_48.svg
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_48.png
│ │ │ ├── Arch_AWS-B2B-Data-Interchange_48.svg
│ │ │ ├── Arch_AWS-Express-Workflows_48.png
│ │ │ ├── Arch_AWS-Express-Workflows_48.svg
│ │ │ ├── Arch_AWS-Step-Functions_48.png
│ │ │ └── Arch_AWS-Step-Functions_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-AppFlow_64.png
│ │ ├── Arch_Amazon-AppFlow_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EventBridge_64.png
│ │ ├── Arch_Amazon-EventBridge_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_64.png
│ │ ├── Arch_Amazon-Managed-Workflows-for-Apache-Airflow_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-MQ_64.png
│ │ ├── Arch_Amazon-MQ_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Simple-Notification-Service_64.png
│ │ ├── Arch_Amazon-Simple-Notification-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Simple-Queue-Service_64.png
│ │ ├── Arch_Amazon-Simple-Queue-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-AppSync_64.png
│ │ ├── Arch_AWS-AppSync_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-B2B-Data-Interchange_64.png
│ │ ├── Arch_AWS-B2B-Data-Interchange_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Express-Workflows_64.png
│ │ ├── Arch_AWS-Express-Workflows_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Step-Functions_64.png
│ │ ├── Arch_AWS-Step-Functions_64.svg
│ │ └── [email protected]
│ ├── artificial-intelligence
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_16.png
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_16.svg
│ │ │ ├── Arch_Amazon-Bedrock_16.png
│ │ │ ├── Arch_Amazon-Bedrock_16.svg
│ │ │ ├── Arch_Amazon-CodeGuru_16.png
│ │ │ ├── Arch_Amazon-CodeGuru_16.svg
│ │ │ ├── Arch_Amazon-CodeWhisperer_16.png
│ │ │ ├── Arch_Amazon-CodeWhisperer_16.svg
│ │ │ ├── Arch_Amazon-Comprehend_16.png
│ │ │ ├── Arch_Amazon-Comprehend_16.svg
│ │ │ ├── Arch_Amazon-Comprehend-Medical_16.png
│ │ │ ├── Arch_Amazon-Comprehend-Medical_16.svg
│ │ │ ├── Arch_Amazon-DevOps-Guru_16.png
│ │ │ ├── Arch_Amazon-DevOps-Guru_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Inference_16.png
│ │ │ ├── Arch_Amazon-Elastic-Inference_16.svg
│ │ │ ├── Arch_Amazon-Forecast_16.png
│ │ │ ├── Arch_Amazon-Forecast_16.svg
│ │ │ ├── Arch_Amazon-Fraud-Detector_16.png
│ │ │ ├── Arch_Amazon-Fraud-Detector_16.svg
│ │ │ ├── Arch_Amazon-Kendra_16.png
│ │ │ ├── Arch_Amazon-Kendra_16.svg
│ │ │ ├── Arch_Amazon-Lex_16.png
│ │ │ ├── Arch_Amazon-Lex_16.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_16.png
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_16.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_16.png
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_16.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_16.png
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_16.svg
│ │ │ ├── Arch_Amazon-Monitron_16.png
│ │ │ ├── Arch_Amazon-Monitron_16.svg
│ │ │ ├── Arch_Amazon-Nova_16.png
│ │ │ ├── Arch_Amazon-Nova_16.svg
│ │ │ ├── Arch_Amazon-Personalize_16.png
│ │ │ ├── Arch_Amazon-Personalize_16.svg
│ │ │ ├── Arch_Amazon-Polly_16.png
│ │ │ ├── Arch_Amazon-Polly_16.svg
│ │ │ ├── Arch_Amazon-Q_16.png
│ │ │ ├── Arch_Amazon-Q_16.svg
│ │ │ ├── Arch_Amazon-Rekognition_16.png
│ │ │ ├── Arch_Amazon-Rekognition_16.svg
│ │ │ ├── Arch_Amazon-SageMaker-AI_16.png
│ │ │ ├── Arch_Amazon-SageMaker-AI_16.svg
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_16.png
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_16.svg
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_16.png
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_16.svg
│ │ │ ├── Arch_Amazon-Textract_16.png
│ │ │ ├── Arch_Amazon-Textract_16.svg
│ │ │ ├── Arch_Amazon-Transcribe_16.png
│ │ │ ├── Arch_Amazon-Transcribe_16.svg
│ │ │ ├── Arch_Amazon-Translate_16.png
│ │ │ ├── Arch_Amazon-Translate_16.svg
│ │ │ ├── Arch_Apache-MXNet-on-AWS_16.png
│ │ │ ├── Arch_Apache-MXNet-on-AWS_16.svg
│ │ │ ├── Arch_AWS-App-Studio_16.png
│ │ │ ├── Arch_AWS-App-Studio_16.svg
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_16.png
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_16.svg
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_16.png
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_16.svg
│ │ │ ├── Arch_AWS-DeepComposer_16.png
│ │ │ ├── Arch_AWS-DeepComposer_16.svg
│ │ │ ├── Arch_AWS-DeepRacer_16.png
│ │ │ ├── Arch_AWS-DeepRacer_16.svg
│ │ │ ├── Arch_AWS-HealthImaging_16.png
│ │ │ ├── Arch_AWS-HealthImaging_16.svg
│ │ │ ├── Arch_AWS-HealthLake_16.png
│ │ │ ├── Arch_AWS-HealthLake_16.svg
│ │ │ ├── Arch_AWS-HealthOmics_16.png
│ │ │ ├── Arch_AWS-HealthOmics_16.svg
│ │ │ ├── Arch_AWS-HealthScribe_16.png
│ │ │ ├── Arch_AWS-HealthScribe_16.svg
│ │ │ ├── Arch_AWS-Neuron_16.png
│ │ │ ├── Arch_AWS-Neuron_16.svg
│ │ │ ├── Arch_AWS-Panorama_16.png
│ │ │ ├── Arch_AWS-Panorama_16.svg
│ │ │ ├── Arch_PyTorch-on-AWS_16.png
│ │ │ ├── Arch_PyTorch-on-AWS_16.svg
│ │ │ ├── Arch_TensorFlow-on-AWS_16.png
│ │ │ └── Arch_TensorFlow-on-AWS_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_32.png
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_32.svg
│ │ │ ├── Arch_Amazon-Bedrock_32.png
│ │ │ ├── Arch_Amazon-Bedrock_32.svg
│ │ │ ├── Arch_Amazon-CodeGuru_32.png
│ │ │ ├── Arch_Amazon-CodeGuru_32.svg
│ │ │ ├── Arch_Amazon-CodeWhisperer_32.png
│ │ │ ├── Arch_Amazon-CodeWhisperer_32.svg
│ │ │ ├── Arch_Amazon-Comprehend_32.png
│ │ │ ├── Arch_Amazon-Comprehend_32.svg
│ │ │ ├── Arch_Amazon-Comprehend-Medical_32.png
│ │ │ ├── Arch_Amazon-Comprehend-Medical_32.svg
│ │ │ ├── Arch_Amazon-DevOps-Guru_32.png
│ │ │ ├── Arch_Amazon-DevOps-Guru_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Inference_32.png
│ │ │ ├── Arch_Amazon-Elastic-Inference_32.svg
│ │ │ ├── Arch_Amazon-Forecast_32.png
│ │ │ ├── Arch_Amazon-Forecast_32.svg
│ │ │ ├── Arch_Amazon-Fraud-Detector_32.png
│ │ │ ├── Arch_Amazon-Fraud-Detector_32.svg
│ │ │ ├── Arch_Amazon-Kendra_32.png
│ │ │ ├── Arch_Amazon-Kendra_32.svg
│ │ │ ├── Arch_Amazon-Lex_32.png
│ │ │ ├── Arch_Amazon-Lex_32.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_32.png
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_32.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_32.png
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_32.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_32.png
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_32.svg
│ │ │ ├── Arch_Amazon-Monitron_32.png
│ │ │ ├── Arch_Amazon-Monitron_32.svg
│ │ │ ├── Arch_Amazon-Nova_32.png
│ │ │ ├── Arch_Amazon-Nova_32.svg
│ │ │ ├── Arch_Amazon-Personalize_32.png
│ │ │ ├── Arch_Amazon-Personalize_32.svg
│ │ │ ├── Arch_Amazon-Polly_32.png
│ │ │ ├── Arch_Amazon-Polly_32.svg
│ │ │ ├── Arch_Amazon-Q_32.png
│ │ │ ├── Arch_Amazon-Q_32.svg
│ │ │ ├── Arch_Amazon-Rekognition_32.png
│ │ │ ├── Arch_Amazon-Rekognition_32.svg
│ │ │ ├── Arch_Amazon-SageMaker-AI_32.png
│ │ │ ├── Arch_Amazon-SageMaker-AI_32.svg
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_32.png
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_32.svg
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_32.png
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_32.svg
│ │ │ ├── Arch_Amazon-Textract_32.png
│ │ │ ├── Arch_Amazon-Textract_32.svg
│ │ │ ├── Arch_Amazon-Transcribe_32.png
│ │ │ ├── Arch_Amazon-Transcribe_32.svg
│ │ │ ├── Arch_Amazon-Translate_32.png
│ │ │ ├── Arch_Amazon-Translate_32.svg
│ │ │ ├── Arch_Apache-MXNet-on-AWS_32.png
│ │ │ ├── Arch_Apache-MXNet-on-AWS_32.svg
│ │ │ ├── Arch_AWS-App-Studio_32.png
│ │ │ ├── Arch_AWS-App-Studio_32.svg
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_32.png
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_32.svg
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_32.png
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_32.svg
│ │ │ ├── Arch_AWS-DeepComposer_32.png
│ │ │ ├── Arch_AWS-DeepComposer_32.svg
│ │ │ ├── Arch_AWS-DeepRacer_32.png
│ │ │ ├── Arch_AWS-DeepRacer_32.svg
│ │ │ ├── Arch_AWS-HealthImaging_32.png
│ │ │ ├── Arch_AWS-HealthImaging_32.svg
│ │ │ ├── Arch_AWS-HealthLake_32.png
│ │ │ ├── Arch_AWS-HealthLake_32.svg
│ │ │ ├── Arch_AWS-HealthOmics_32.png
│ │ │ ├── Arch_AWS-HealthOmics_32.svg
│ │ │ ├── Arch_AWS-HealthScribe_32.png
│ │ │ ├── Arch_AWS-HealthScribe_32.svg
│ │ │ ├── Arch_AWS-Neuron_32.png
│ │ │ ├── Arch_AWS-Neuron_32.svg
│ │ │ ├── Arch_AWS-Panorama_32.png
│ │ │ ├── Arch_AWS-Panorama_32.svg
│ │ │ ├── Arch_PyTorch-on-AWS_32.png
│ │ │ ├── Arch_PyTorch-on-AWS_32.svg
│ │ │ ├── Arch_TensorFlow-on-AWS_32.png
│ │ │ └── Arch_TensorFlow-on-AWS_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_48.png
│ │ │ ├── Arch_Amazon-Augmented-AI-A2I_48.svg
│ │ │ ├── Arch_Amazon-Bedrock_48.png
│ │ │ ├── Arch_Amazon-Bedrock_48.svg
│ │ │ ├── Arch_Amazon-CodeGuru_48.png
│ │ │ ├── Arch_Amazon-CodeGuru_48.svg
│ │ │ ├── Arch_Amazon-CodeWhisperer_48.png
│ │ │ ├── Arch_Amazon-CodeWhisperer_48.svg
│ │ │ ├── Arch_Amazon-Comprehend_48.png
│ │ │ ├── Arch_Amazon-Comprehend_48.svg
│ │ │ ├── Arch_Amazon-Comprehend-Medical_48.png
│ │ │ ├── Arch_Amazon-Comprehend-Medical_48.svg
│ │ │ ├── Arch_Amazon-DevOps-Guru_48.png
│ │ │ ├── Arch_Amazon-DevOps-Guru_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Inference_48.png
│ │ │ ├── Arch_Amazon-Elastic-Inference_48.svg
│ │ │ ├── Arch_Amazon-Forecast_48.png
│ │ │ ├── Arch_Amazon-Forecast_48.svg
│ │ │ ├── Arch_Amazon-Fraud-Detector_48.png
│ │ │ ├── Arch_Amazon-Fraud-Detector_48.svg
│ │ │ ├── Arch_Amazon-Kendra_48.png
│ │ │ ├── Arch_Amazon-Kendra_48.svg
│ │ │ ├── Arch_Amazon-Lex_48.png
│ │ │ ├── Arch_Amazon-Lex_48.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_48.png
│ │ │ ├── Arch_Amazon-Lookout-for-Equipment_48.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_48.png
│ │ │ ├── Arch_Amazon-Lookout-for-Metrics_48.svg
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_48.png
│ │ │ ├── Arch_Amazon-Lookout-for-Vision_48.svg
│ │ │ ├── Arch_Amazon-Monitron_48.png
│ │ │ ├── Arch_Amazon-Monitron_48.svg
│ │ │ ├── Arch_Amazon-Nova_48.png
│ │ │ ├── Arch_Amazon-Nova_48.svg
│ │ │ ├── Arch_Amazon-Personalize_48.png
│ │ │ ├── Arch_Amazon-Personalize_48.svg
│ │ │ ├── Arch_Amazon-Polly_48.png
│ │ │ ├── Arch_Amazon-Polly_48.svg
│ │ │ ├── Arch_Amazon-Q_48.png
│ │ │ ├── Arch_Amazon-Q_48.svg
│ │ │ ├── Arch_Amazon-Rekognition_48.png
│ │ │ ├── Arch_Amazon-Rekognition_48.svg
│ │ │ ├── Arch_Amazon-SageMaker-AI_48.png
│ │ │ ├── Arch_Amazon-SageMaker-AI_48.svg
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_48.png
│ │ │ ├── Arch_Amazon-SageMaker-Ground-Truth_48.svg
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_48.png
│ │ │ ├── Arch_Amazon-SageMaker-Studio-Lab_48.svg
│ │ │ ├── Arch_Amazon-Textract_48.png
│ │ │ ├── Arch_Amazon-Textract_48.svg
│ │ │ ├── Arch_Amazon-Transcribe_48.png
│ │ │ ├── Arch_Amazon-Transcribe_48.svg
│ │ │ ├── Arch_Amazon-Translate_48.png
│ │ │ ├── Arch_Amazon-Translate_48.svg
│ │ │ ├── Arch_Apache-MXNet-on-AWS_48.png
│ │ │ ├── Arch_Apache-MXNet-on-AWS_48.svg
│ │ │ ├── Arch_AWS-App-Studio_48.png
│ │ │ ├── Arch_AWS-App-Studio_48.svg
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_48.png
│ │ │ ├── Arch_AWS-Deep-Learning-AMIs_48.svg
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_48.png
│ │ │ ├── Arch_AWS-Deep-Learning-Containers_48.svg
│ │ │ ├── Arch_AWS-DeepComposer_48.png
│ │ │ ├── Arch_AWS-DeepComposer_48.svg
│ │ │ ├── Arch_AWS-DeepRacer_48.png
│ │ │ ├── Arch_AWS-DeepRacer_48.svg
│ │ │ ├── Arch_AWS-HealthImaging_48.png
│ │ │ ├── Arch_AWS-HealthImaging_48.svg
│ │ │ ├── Arch_AWS-HealthLake_48.png
│ │ │ ├── Arch_AWS-HealthLake_48.svg
│ │ │ ├── Arch_AWS-HealthOmics_48.png
│ │ │ ├── Arch_AWS-HealthOmics_48.svg
│ │ │ ├── Arch_AWS-HealthScribe_48.png
│ │ │ ├── Arch_AWS-HealthScribe_48.svg
│ │ │ ├── Arch_AWS-Neuron_48.png
│ │ │ ├── Arch_AWS-Neuron_48.svg
│ │ │ ├── Arch_AWS-Panorama_48.png
│ │ │ ├── Arch_AWS-Panorama_48.svg
│ │ │ ├── Arch_PyTorch-on-AWS_48.png
│ │ │ ├── Arch_PyTorch-on-AWS_48.svg
│ │ │ ├── Arch_TensorFlow-on-AWS_48.png
│ │ │ └── Arch_TensorFlow-on-AWS_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Augmented-AI-A2I_64.png
│ │ ├── Arch_Amazon-Augmented-AI-A2I_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Bedrock_64.png
│ │ ├── Arch_Amazon-Bedrock_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CodeGuru_64.png
│ │ ├── Arch_Amazon-CodeGuru_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CodeWhisperer_64.png
│ │ ├── Arch_Amazon-CodeWhisperer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Comprehend_64.png
│ │ ├── Arch_Amazon-Comprehend_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Comprehend-Medical_64.png
│ │ ├── Arch_Amazon-Comprehend-Medical_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DevOps-Guru_64.png
│ │ ├── Arch_Amazon-DevOps-Guru_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Inference_64.png
│ │ ├── Arch_Amazon-Elastic-Inference_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Forecast_64.png
│ │ ├── Arch_Amazon-Forecast_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Fraud-Detector_64.png
│ │ ├── Arch_Amazon-Fraud-Detector_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kendra_64.png
│ │ ├── Arch_Amazon-Kendra_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lex_64.png
│ │ ├── Arch_Amazon-Lex_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lookout-for-Equipment_64.png
│ │ ├── Arch_Amazon-Lookout-for-Equipment_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lookout-for-Metrics_64.png
│ │ ├── Arch_Amazon-Lookout-for-Metrics_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lookout-for-Vision_64.png
│ │ ├── Arch_Amazon-Lookout-for-Vision_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Monitron_64.png
│ │ ├── Arch_Amazon-Monitron_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Nova_64.png
│ │ ├── Arch_Amazon-Nova_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Personalize_64.png
│ │ ├── Arch_Amazon-Personalize_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Polly_64.png
│ │ ├── Arch_Amazon-Polly_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Q_64.png
│ │ ├── Arch_Amazon-Q_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Rekognition_64.png
│ │ ├── Arch_Amazon-Rekognition_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker-AI_64.png
│ │ ├── Arch_Amazon-SageMaker-AI_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker-Ground-Truth_64.png
│ │ ├── Arch_Amazon-SageMaker-Ground-Truth_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-SageMaker-Studio-Lab_64.png
│ │ ├── Arch_Amazon-SageMaker-Studio-Lab_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Textract_64.png
│ │ ├── Arch_Amazon-Textract_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Transcribe_64.png
│ │ ├── Arch_Amazon-Transcribe_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Translate_64.png
│ │ ├── Arch_Amazon-Translate_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Apache-MXNet-on-AWS_64.png
│ │ ├── Arch_Apache-MXNet-on-AWS_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-App-Studio_64.png
│ │ ├── Arch_AWS-App-Studio_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Deep-Learning-AMIs_64.png
│ │ ├── Arch_AWS-Deep-Learning-AMIs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Deep-Learning-Containers_64.png
│ │ ├── Arch_AWS-Deep-Learning-Containers_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-DeepComposer_64.png
│ │ ├── Arch_AWS-DeepComposer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-DeepRacer_64.png
│ │ ├── Arch_AWS-DeepRacer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthImaging_64.png
│ │ ├── Arch_AWS-HealthImaging_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthLake_64.png
│ │ ├── Arch_AWS-HealthLake_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthOmics_64.png
│ │ ├── Arch_AWS-HealthOmics_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-HealthScribe_64.png
│ │ ├── Arch_AWS-HealthScribe_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Neuron_64.png
│ │ ├── Arch_AWS-Neuron_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Panorama_64.png
│ │ ├── Arch_AWS-Panorama_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_PyTorch-on-AWS_64.png
│ │ ├── Arch_PyTorch-on-AWS_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_TensorFlow-on-AWS_64.png
│ │ ├── Arch_TensorFlow-on-AWS_64.svg
│ │ └── [email protected]
│ ├── blockchain
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Managed-Blockchain_16.png
│ │ │ ├── Arch_Amazon-Managed-Blockchain_16.svg
│ │ │ ├── Arch_Amazon-Quantum-Ledger-Database_16.png
│ │ │ └── Arch_Amazon-Quantum-Ledger-Database_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Managed-Blockchain_32.png
│ │ │ ├── Arch_Amazon-Managed-Blockchain_32.svg
│ │ │ ├── Arch_Amazon-Quantum-Ledger-Database_32.png
│ │ │ └── Arch_Amazon-Quantum-Ledger-Database_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Managed-Blockchain_48.png
│ │ │ ├── Arch_Amazon-Managed-Blockchain_48.svg
│ │ │ ├── Arch_Amazon-Quantum-Ledger-Database_48.png
│ │ │ └── Arch_Amazon-Quantum-Ledger-Database_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Managed-Blockchain_64.png
│ │ ├── Arch_Amazon-Managed-Blockchain_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Quantum-Ledger-Database_64.png
│ │ ├── Arch_Amazon-Quantum-Ledger-Database_64.svg
│ │ └── [email protected]
│ ├── business-applications
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Alexa-For-Business_16.png
│ │ │ ├── Arch_Alexa-For-Business_16.svg
│ │ │ ├── Arch_Amazon-Chime_16.png
│ │ │ ├── Arch_Amazon-Chime_16.svg
│ │ │ ├── Arch_Amazon-Chime-SDK_16.png
│ │ │ ├── Arch_Amazon-Chime-SDK_16.svg
│ │ │ ├── Arch_Amazon-Connect_16.png
│ │ │ ├── Arch_Amazon-Connect_16.svg
│ │ │ ├── Arch_Amazon-Pinpoint_16.png
│ │ │ ├── Arch_Amazon-Pinpoint_16.svg
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_16.png
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_16.svg
│ │ │ ├── Arch_Amazon-Simple-Email-Service_16.png
│ │ │ ├── Arch_Amazon-Simple-Email-Service_16.svg
│ │ │ ├── Arch_Amazon-WorkDocs_16.png
│ │ │ ├── Arch_Amazon-WorkDocs_16.svg
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_16.png
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_16.svg
│ │ │ ├── Arch_Amazon-WorkMail_16.png
│ │ │ ├── Arch_Amazon-WorkMail_16.svg
│ │ │ ├── Arch_AWS-AppFabric_16.png
│ │ │ ├── Arch_AWS-AppFabric_16.svg
│ │ │ ├── Arch_AWS-End-User-Messaging_16.png
│ │ │ ├── Arch_AWS-End-User-Messaging_16.svg
│ │ │ ├── Arch_AWS-Supply-Chain_16.png
│ │ │ ├── Arch_AWS-Supply-Chain_16.svg
│ │ │ ├── Arch_AWS-Wickr_16.png
│ │ │ └── Arch_AWS-Wickr_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Alexa-For-Business_32.png
│ │ │ ├── Arch_Alexa-For-Business_32.svg
│ │ │ ├── Arch_Amazon-Chime_32.png
│ │ │ ├── Arch_Amazon-Chime_32.svg
│ │ │ ├── Arch_Amazon-Chime-SDK_32.png
│ │ │ ├── Arch_Amazon-Chime-SDK_32.svg
│ │ │ ├── Arch_Amazon-Connect_32.png
│ │ │ ├── Arch_Amazon-Connect_32.svg
│ │ │ ├── Arch_Amazon-Pinpoint_32.png
│ │ │ ├── Arch_Amazon-Pinpoint_32.svg
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_32.png
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_32.svg
│ │ │ ├── Arch_Amazon-Simple-Email-Service_32.png
│ │ │ ├── Arch_Amazon-Simple-Email-Service_32.svg
│ │ │ ├── Arch_Amazon-WorkDocs_32.png
│ │ │ ├── Arch_Amazon-WorkDocs_32.svg
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_32.png
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_32.svg
│ │ │ ├── Arch_Amazon-WorkMail_32.png
│ │ │ ├── Arch_Amazon-WorkMail_32.svg
│ │ │ ├── Arch_AWS-AppFabric_32.png
│ │ │ ├── Arch_AWS-AppFabric_32.svg
│ │ │ ├── Arch_AWS-End-User-Messaging_32.png
│ │ │ ├── Arch_AWS-End-User-Messaging_32.svg
│ │ │ ├── Arch_AWS-Supply-Chain_32.png
│ │ │ ├── Arch_AWS-Supply-Chain_32.svg
│ │ │ ├── Arch_AWS-Wickr_32.png
│ │ │ └── Arch_AWS-Wickr_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Alexa-For-Business_48.png
│ │ │ ├── Arch_Alexa-For-Business_48.svg
│ │ │ ├── Arch_Amazon-Chime_48.png
│ │ │ ├── Arch_Amazon-Chime_48.svg
│ │ │ ├── Arch_Amazon-Chime-SDK_48.png
│ │ │ ├── Arch_Amazon-Chime-SDK_48.svg
│ │ │ ├── Arch_Amazon-Connect_48.png
│ │ │ ├── Arch_Amazon-Connect_48.svg
│ │ │ ├── Arch_Amazon-Pinpoint_48.png
│ │ │ ├── Arch_Amazon-Pinpoint_48.svg
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_48.png
│ │ │ ├── Arch_Amazon-Pinpoint-APIs_48.svg
│ │ │ ├── Arch_Amazon-Simple-Email-Service_48.png
│ │ │ ├── Arch_Amazon-Simple-Email-Service_48.svg
│ │ │ ├── Arch_Amazon-WorkDocs_48.png
│ │ │ ├── Arch_Amazon-WorkDocs_48.svg
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_48.png
│ │ │ ├── Arch_Amazon-WorkDocs-SDK_48.svg
│ │ │ ├── Arch_Amazon-WorkMail_48.png
│ │ │ ├── Arch_Amazon-WorkMail_48.svg
│ │ │ ├── Arch_AWS-AppFabric_48.png
│ │ │ ├── Arch_AWS-AppFabric_48.svg
│ │ │ ├── Arch_AWS-End-User-Messaging_48.png
│ │ │ ├── Arch_AWS-End-User-Messaging_48.svg
│ │ │ ├── Arch_AWS-Supply-Chain_48.png
│ │ │ ├── Arch_AWS-Supply-Chain_48.svg
│ │ │ ├── Arch_AWS-Wickr_48.png
│ │ │ └── Arch_AWS-Wickr_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Alexa-For-Business_64.png
│ │ ├── Arch_Alexa-For-Business_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Chime_64.png
│ │ ├── Arch_Amazon-Chime_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Chime-SDK_64.png
│ │ ├── Arch_Amazon-Chime-SDK_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Connect_64.png
│ │ ├── Arch_Amazon-Connect_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Pinpoint_64.png
│ │ ├── Arch_Amazon-Pinpoint_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Pinpoint-APIs_64.png
│ │ ├── Arch_Amazon-Pinpoint-APIs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Simple-Email-Service_64.png
│ │ ├── Arch_Amazon-Simple-Email-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkDocs_64.png
│ │ ├── Arch_Amazon-WorkDocs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkDocs-SDK_64.png
│ │ ├── Arch_Amazon-WorkDocs-SDK_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkMail_64.png
│ │ ├── Arch_Amazon-WorkMail_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-AppFabric_64.png
│ │ ├── Arch_AWS-AppFabric_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-End-User-Messaging_64.png
│ │ ├── Arch_AWS-End-User-Messaging_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Supply-Chain_64.png
│ │ ├── Arch_AWS-Supply-Chain_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Wickr_64.png
│ │ ├── Arch_AWS-Wickr_64.svg
│ │ └── [email protected]
│ ├── cloud-financial
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Billing-Conductor_16.png
│ │ │ ├── Arch_AWS-Billing-Conductor_16.svg
│ │ │ ├── Arch_AWS-Budgets_16.png
│ │ │ ├── Arch_AWS-Budgets_16.svg
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_16.png
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_16.svg
│ │ │ ├── Arch_AWS-Cost-Explorer_16.png
│ │ │ ├── Arch_AWS-Cost-Explorer_16.svg
│ │ │ ├── Arch_Reserved-Instance-Reporting_16.png
│ │ │ ├── Arch_Reserved-Instance-Reporting_16.svg
│ │ │ ├── Arch_Savings-Plans_16.png
│ │ │ └── Arch_Savings-Plans_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Billing-Conductor_32.png
│ │ │ ├── Arch_AWS-Billing-Conductor_32.svg
│ │ │ ├── Arch_AWS-Budgets_32.png
│ │ │ ├── Arch_AWS-Budgets_32.svg
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_32.png
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_32.svg
│ │ │ ├── Arch_AWS-Cost-Explorer_32.png
│ │ │ ├── Arch_AWS-Cost-Explorer_32.svg
│ │ │ ├── Arch_Reserved-Instance-Reporting_32.png
│ │ │ ├── Arch_Reserved-Instance-Reporting_32.svg
│ │ │ ├── Arch_Savings-Plans_32.png
│ │ │ └── Arch_Savings-Plans_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Billing-Conductor_48.png
│ │ │ ├── Arch_AWS-Billing-Conductor_48.svg
│ │ │ ├── Arch_AWS-Budgets_48.png
│ │ │ ├── Arch_AWS-Budgets_48.svg
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_48.png
│ │ │ ├── Arch_AWS-Cost-and-Usage-Report_48.svg
│ │ │ ├── Arch_AWS-Cost-Explorer_48.png
│ │ │ ├── Arch_AWS-Cost-Explorer_48.svg
│ │ │ ├── Arch_Reserved-Instance-Reporting_48.png
│ │ │ ├── Arch_Reserved-Instance-Reporting_48.svg
│ │ │ ├── Arch_Savings-Plans_48.png
│ │ │ └── Arch_Savings-Plans_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_AWS-Billing-Conductor_64.png
│ │ ├── Arch_AWS-Billing-Conductor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Budgets_64.png
│ │ ├── Arch_AWS-Budgets_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cost-and-Usage-Report_64.png
│ │ ├── Arch_AWS-Cost-and-Usage-Report_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cost-Explorer_64.png
│ │ ├── Arch_AWS-Cost-Explorer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Reserved-Instance-Reporting_64.png
│ │ ├── Arch_Reserved-Instance-Reporting_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Savings-Plans_64.png
│ │ ├── Arch_Savings-Plans_64.svg
│ │ └── [email protected]
│ ├── compute
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-DCV_16.png
│ │ │ ├── Arch_Amazon-DCV_16.svg
│ │ │ ├── Arch_Amazon-EC2_16.png
│ │ │ ├── Arch_Amazon-EC2_16.svg
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_16.png
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_16.svg
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_16.png
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_16.svg
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_16.png
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_16.svg
│ │ │ ├── Arch_Amazon-Lightsail_16.png
│ │ │ ├── Arch_Amazon-Lightsail_16.svg
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_16.png
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_16.svg
│ │ │ ├── Arch_AWS-App-Runner_16.png
│ │ │ ├── Arch_AWS-App-Runner_16.svg
│ │ │ ├── Arch_AWS-Batch_16.png
│ │ │ ├── Arch_AWS-Batch_16.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.svg
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_16.png
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_16.svg
│ │ │ ├── Arch_AWS-Lambda_16.png
│ │ │ ├── Arch_AWS-Lambda_16.svg
│ │ │ ├── Arch_AWS-Local-Zones_16.png
│ │ │ ├── Arch_AWS-Local-Zones_16.svg
│ │ │ ├── Arch_AWS-Nitro-Enclaves_16.png
│ │ │ ├── Arch_AWS-Nitro-Enclaves_16.svg
│ │ │ ├── Arch_AWS-Outposts-family_16.png
│ │ │ ├── Arch_AWS-Outposts-family_16.svg
│ │ │ ├── Arch_AWS-Outposts-rack_16.png
│ │ │ ├── Arch_AWS-Outposts-rack_16.svg
│ │ │ ├── Arch_AWS-Outposts-servers_16.png
│ │ │ ├── Arch_AWS-Outposts-servers_16.svg
│ │ │ ├── Arch_AWS-Parallel-Cluster_16.png
│ │ │ ├── Arch_AWS-Parallel-Cluster_16.svg
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_16.png
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_16.svg
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_16.png
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_16.svg
│ │ │ ├── Arch_AWS-SimSpace-Weaver_16.png
│ │ │ ├── Arch_AWS-SimSpace-Weaver_16.svg
│ │ │ ├── Arch_AWS-Wavelength_16.png
│ │ │ ├── Arch_AWS-Wavelength_16.svg
│ │ │ ├── Arch_Bottlerocket_16.png
│ │ │ ├── Arch_Bottlerocket_16.svg
│ │ │ ├── Arch_Elastic-Fabric-Adapter_16.png
│ │ │ ├── Arch_Elastic-Fabric-Adapter_16.svg
│ │ │ ├── Arch_NICE-EnginFrame_16.png
│ │ │ └── Arch_NICE-EnginFrame_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-DCV_32.png
│ │ │ ├── Arch_Amazon-DCV_32.svg
│ │ │ ├── Arch_Amazon-EC2_32.png
│ │ │ ├── Arch_Amazon-EC2_32.svg
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_32.png
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_32.svg
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_32.png
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_32.svg
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_32.png
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_32.svg
│ │ │ ├── Arch_Amazon-Lightsail_32.png
│ │ │ ├── Arch_Amazon-Lightsail_32.svg
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_32.png
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_32.svg
│ │ │ ├── Arch_AWS-App-Runner_32.png
│ │ │ ├── Arch_AWS-App-Runner_32.svg
│ │ │ ├── Arch_AWS-Batch_32.png
│ │ │ ├── Arch_AWS-Batch_32.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.svg
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_32.png
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_32.svg
│ │ │ ├── Arch_AWS-Lambda_32.png
│ │ │ ├── Arch_AWS-Lambda_32.svg
│ │ │ ├── Arch_AWS-Local-Zones_32.png
│ │ │ ├── Arch_AWS-Local-Zones_32.svg
│ │ │ ├── Arch_AWS-Nitro-Enclaves_32.png
│ │ │ ├── Arch_AWS-Nitro-Enclaves_32.svg
│ │ │ ├── Arch_AWS-Outposts-family_32.png
│ │ │ ├── Arch_AWS-Outposts-family_32.svg
│ │ │ ├── Arch_AWS-Outposts-rack_32.png
│ │ │ ├── Arch_AWS-Outposts-rack_32.svg
│ │ │ ├── Arch_AWS-Outposts-servers_32.png
│ │ │ ├── Arch_AWS-Outposts-servers_32.svg
│ │ │ ├── Arch_AWS-Parallel-Cluster_32.png
│ │ │ ├── Arch_AWS-Parallel-Cluster_32.svg
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_32.png
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_32.svg
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_32.png
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_32.svg
│ │ │ ├── Arch_AWS-SimSpace-Weaver_32.png
│ │ │ ├── Arch_AWS-SimSpace-Weaver_32.svg
│ │ │ ├── Arch_AWS-Wavelength_32.png
│ │ │ ├── Arch_AWS-Wavelength_32.svg
│ │ │ ├── Arch_Bottlerocket_32.png
│ │ │ ├── Arch_Bottlerocket_32.svg
│ │ │ ├── Arch_Elastic-Fabric-Adapter_32.png
│ │ │ ├── Arch_Elastic-Fabric-Adapter_32.svg
│ │ │ ├── Arch_NICE-EnginFrame_32.png
│ │ │ └── Arch_NICE-EnginFrame_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-DCV_48.png
│ │ │ ├── Arch_Amazon-DCV_48.svg
│ │ │ ├── Arch_Amazon-EC2_48.png
│ │ │ ├── Arch_Amazon-EC2_48.svg
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_48.png
│ │ │ ├── Arch_Amazon-EC2-Auto-Scaling_48.svg
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_48.png
│ │ │ ├── Arch_Amazon-EC2-Image-Builder_48.svg
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_48.png
│ │ │ ├── Arch_Amazon-Elastic-VMware-Service_48.svg
│ │ │ ├── Arch_Amazon-Lightsail_48.png
│ │ │ ├── Arch_Amazon-Lightsail_48.svg
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_48.png
│ │ │ ├── Arch_Amazon-Lightsail-for-Research_48.svg
│ │ │ ├── Arch_AWS-App-Runner_48.png
│ │ │ ├── Arch_AWS-App-Runner_48.svg
│ │ │ ├── Arch_AWS-Batch_48.png
│ │ │ ├── Arch_AWS-Batch_48.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.svg
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_48.png
│ │ │ ├── Arch_AWS-Elastic-Beanstalk_48.svg
│ │ │ ├── Arch_AWS-Lambda_48.png
│ │ │ ├── Arch_AWS-Lambda_48.svg
│ │ │ ├── Arch_AWS-Local-Zones_48.png
│ │ │ ├── Arch_AWS-Local-Zones_48.svg
│ │ │ ├── Arch_AWS-Nitro-Enclaves_48.png
│ │ │ ├── Arch_AWS-Nitro-Enclaves_48.svg
│ │ │ ├── Arch_AWS-Outposts-family_48.png
│ │ │ ├── Arch_AWS-Outposts-family_48.svg
│ │ │ ├── Arch_AWS-Outposts-rack_48.png
│ │ │ ├── Arch_AWS-Outposts-rack_48.svg
│ │ │ ├── Arch_AWS-Outposts-servers_48.png
│ │ │ ├── Arch_AWS-Outposts-servers_48.svg
│ │ │ ├── Arch_AWS-Parallel-Cluster_48.png
│ │ │ ├── Arch_AWS-Parallel-Cluster_48.svg
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_48.png
│ │ │ ├── Arch_AWS-Parallel-Computing-Service_48.svg
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_48.png
│ │ │ ├── Arch_AWS-Serverless-Application-Repository_48.svg
│ │ │ ├── Arch_AWS-SimSpace-Weaver_48.png
│ │ │ ├── Arch_AWS-SimSpace-Weaver_48.svg
│ │ │ ├── Arch_AWS-Wavelength_48.png
│ │ │ ├── Arch_AWS-Wavelength_48.svg
│ │ │ ├── Arch_Bottlerocket_48.png
│ │ │ ├── Arch_Bottlerocket_48.svg
│ │ │ ├── Arch_Elastic-Fabric-Adapter_48.png
│ │ │ ├── Arch_Elastic-Fabric-Adapter_48.svg
│ │ │ ├── Arch_NICE-EnginFrame_48.png
│ │ │ └── Arch_NICE-EnginFrame_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-DCV_64.png
│ │ ├── Arch_Amazon-DCV_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EC2_64.png
│ │ ├── Arch_Amazon-EC2_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EC2-Auto-Scaling_64.png
│ │ ├── Arch_Amazon-EC2-Auto-Scaling_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EC2-Image-Builder_64.png
│ │ ├── Arch_Amazon-EC2-Image-Builder_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-VMware-Service_64.png
│ │ ├── Arch_Amazon-Elastic-VMware-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lightsail_64.png
│ │ ├── Arch_Amazon-Lightsail_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Lightsail-for-Research_64.png
│ │ ├── Arch_Amazon-Lightsail-for-Research_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-App-Runner_64.png
│ │ ├── Arch_AWS-App-Runner_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Batch_64.png
│ │ ├── Arch_AWS-Batch_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Compute-Optimizer_64.png
│ │ ├── Arch_AWS-Compute-Optimizer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elastic-Beanstalk_64.png
│ │ ├── Arch_AWS-Elastic-Beanstalk_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Lambda_64.png
│ │ ├── Arch_AWS-Lambda_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Local-Zones_64.png
│ │ ├── Arch_AWS-Local-Zones_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Nitro-Enclaves_64.png
│ │ ├── Arch_AWS-Nitro-Enclaves_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Outposts-family_64.png
│ │ ├── Arch_AWS-Outposts-family_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Outposts-rack_64.png
│ │ ├── Arch_AWS-Outposts-rack_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Outposts-servers_64.png
│ │ ├── Arch_AWS-Outposts-servers_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Parallel-Cluster_64.png
│ │ ├── Arch_AWS-Parallel-Cluster_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Parallel-Computing-Service_64.png
│ │ ├── Arch_AWS-Parallel-Computing-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Serverless-Application-Repository_64.png
│ │ ├── Arch_AWS-Serverless-Application-Repository_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-SimSpace-Weaver_64.png
│ │ ├── Arch_AWS-SimSpace-Weaver_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Wavelength_64.png
│ │ ├── Arch_AWS-Wavelength_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Bottlerocket_64.png
│ │ ├── Arch_Bottlerocket_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Elastic-Fabric-Adapter_64.png
│ │ ├── Arch_Elastic-Fabric-Adapter_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_NICE-EnginFrame_64.png
│ │ ├── Arch_NICE-EnginFrame_64.svg
│ │ └── [email protected]
│ ├── containers
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-ECS-Anywhere_16.png
│ │ │ ├── Arch_Amazon-ECS-Anywhere_16.svg
│ │ │ ├── Arch_Amazon-EKS-Anywhere_16.png
│ │ │ ├── Arch_Amazon-EKS-Anywhere_16.svg
│ │ │ ├── Arch_Amazon-EKS-Cloud_16.png
│ │ │ ├── Arch_Amazon-EKS-Cloud_16.svg
│ │ │ ├── Arch_Amazon-EKS-Distro_16.png
│ │ │ ├── Arch_Amazon-EKS-Distro_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_16.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_16.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_16.svg
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_16.png
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_16.svg
│ │ │ ├── Arch_AWS-Fargate_16.png
│ │ │ ├── Arch_AWS-Fargate_16.svg
│ │ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_16.png
│ │ │ └── Arch_Red-Hat-OpenShift-Service-on-AWS_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-ECS-Anywhere_32.png
│ │ │ ├── Arch_Amazon-ECS-Anywhere_32.svg
│ │ │ ├── Arch_Amazon-EKS-Anywhere_32.png
│ │ │ ├── Arch_Amazon-EKS-Anywhere_32.svg
│ │ │ ├── Arch_Amazon-EKS-Cloud_32.png
│ │ │ ├── Arch_Amazon-EKS-Cloud_32.svg
│ │ │ ├── Arch_Amazon-EKS-Distro_32.png
│ │ │ ├── Arch_Amazon-EKS-Distro_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_32.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_32.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_32.svg
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_32.png
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_32.svg
│ │ │ ├── Arch_AWS-Fargate_32.png
│ │ │ ├── Arch_AWS-Fargate_32.svg
│ │ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_32.png
│ │ │ └── Arch_Red-Hat-OpenShift-Service-on-AWS_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-ECS-Anywhere_48.png
│ │ │ ├── Arch_Amazon-ECS-Anywhere_48.svg
│ │ │ ├── Arch_Amazon-EKS-Anywhere_48.png
│ │ │ ├── Arch_Amazon-EKS-Anywhere_48.svg
│ │ │ ├── Arch_Amazon-EKS-Cloud_48.png
│ │ │ ├── Arch_Amazon-EKS-Cloud_48.svg
│ │ │ ├── Arch_Amazon-EKS-Distro_48.png
│ │ │ ├── Arch_Amazon-EKS-Distro_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_48.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Registry_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_48.png
│ │ │ ├── Arch_Amazon-Elastic-Container-Service_48.svg
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_48.png
│ │ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_48.svg
│ │ │ ├── Arch_AWS-Fargate_48.png
│ │ │ ├── Arch_AWS-Fargate_48.svg
│ │ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_48.png
│ │ │ └── Arch_Red-Hat-OpenShift-Service-on-AWS_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-ECS-Anywhere_64.png
│ │ ├── Arch_Amazon-ECS-Anywhere_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EKS-Anywhere_64.png
│ │ ├── Arch_Amazon-EKS-Anywhere_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EKS-Cloud_64.png
│ │ ├── Arch_Amazon-EKS-Cloud_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-EKS-Distro_64.png
│ │ ├── Arch_Amazon-EKS-Distro_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Container-Registry_64.png
│ │ ├── Arch_Amazon-Elastic-Container-Registry_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Container-Service_64.png
│ │ ├── Arch_Amazon-Elastic-Container-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_64.png
│ │ ├── Arch_Amazon-Elastic-Kubernetes-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Fargate_64.png
│ │ ├── Arch_AWS-Fargate_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_64.png
│ │ ├── Arch_Red-Hat-OpenShift-Service-on-AWS_64.svg
│ │ └── [email protected]
│ ├── customer-enablement
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_AWS-Activate_16.png
│ │ │ ├── Arch_AWS-Activate_16.svg
│ │ │ ├── Arch_AWS-IQ_16.png
│ │ │ ├── Arch_AWS-IQ_16.svg
│ │ │ ├── Arch_AWS-Managed-Services_16.png
│ │ │ ├── Arch_AWS-Managed-Services_16.svg
│ │ │ ├── Arch_AWS-Professional-Services_16.png
│ │ │ ├── Arch_AWS-Professional-Services_16.svg
│ │ │ ├── Arch_AWS-rePost_16.png
│ │ │ ├── Arch_AWS-rePost_16.svg
│ │ │ ├── Arch_AWS-rePost-Private_16.png
│ │ │ ├── Arch_AWS-rePost-Private_16.svg
│ │ │ ├── Arch_AWS-Support_16.png
│ │ │ ├── Arch_AWS-Support_16.svg
│ │ │ ├── Arch_AWS-Training-Certification_16.png
│ │ │ └── Arch_AWS-Training-Certification_16.svg
│ │ ├── 32
│ │ │ ├── Arch_AWS-Activate_32.png
│ │ │ ├── Arch_AWS-Activate_32.svg
│ │ │ ├── Arch_AWS-IQ_32.png
│ │ │ ├── Arch_AWS-IQ_32.svg
│ │ │ ├── Arch_AWS-Managed-Services_32.png
│ │ │ ├── Arch_AWS-Managed-Services_32.svg
│ │ │ ├── Arch_AWS-Professional-Services_32.png
│ │ │ ├── Arch_AWS-Professional-Services_32.svg
│ │ │ ├── Arch_AWS-rePost_32.png
│ │ │ ├── Arch_AWS-rePost_32.svg
│ │ │ ├── Arch_AWS-rePost-Private_32.png
│ │ │ ├── Arch_AWS-rePost-Private_32.svg
│ │ │ ├── Arch_AWS-Support_32.png
│ │ │ ├── Arch_AWS-Support_32.svg
│ │ │ ├── Arch_AWS-Training-Certification_32.png
│ │ │ └── Arch_AWS-Training-Certification_32.svg
│ │ ├── 48
│ │ │ ├── Arch_AWS-Activate_48.png
│ │ │ ├── Arch_AWS-Activate_48.svg
│ │ │ ├── Arch_AWS-IQ_48.png
│ │ │ ├── Arch_AWS-IQ_48.svg
│ │ │ ├── Arch_AWS-Managed-Services_48.png
│ │ │ ├── Arch_AWS-Managed-Services_48.svg
│ │ │ ├── Arch_AWS-Professional-Services_48.png
│ │ │ ├── Arch_AWS-Professional-Services_48.svg
│ │ │ ├── Arch_AWS-rePost_48.png
│ │ │ ├── Arch_AWS-rePost_48.svg
│ │ │ ├── Arch_AWS-rePost-Private_48.png
│ │ │ ├── Arch_AWS-rePost-Private_48.svg
│ │ │ ├── Arch_AWS-Support_48.png
│ │ │ ├── Arch_AWS-Support_48.svg
│ │ │ ├── Arch_AWS-Training-Certification_48.png
│ │ │ └── Arch_AWS-Training-Certification_48.svg
│ │ └── 64
│ │ ├── Arch_AWS-Activate_64.png
│ │ ├── Arch_AWS-Activate_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IQ_64.png
│ │ ├── Arch_AWS-IQ_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Managed-Services_64.png
│ │ ├── Arch_AWS-Managed-Services_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Professional-Services_64.png
│ │ ├── Arch_AWS-Professional-Services_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-rePost_64.png
│ │ ├── Arch_AWS-rePost_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-rePost-Private_64.png
│ │ ├── Arch_AWS-rePost-Private_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Support_64.png
│ │ ├── Arch_AWS-Support_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Training-Certification_64.png
│ │ ├── Arch_AWS-Training-Certification_64.svg
│ │ └── [email protected]
│ ├── database
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Aurora_16.png
│ │ │ ├── Arch_Amazon-Aurora_16.svg
│ │ │ ├── Arch_Amazon-DocumentDB_16.png
│ │ │ ├── Arch_Amazon-DocumentDB_16.svg
│ │ │ ├── Arch_Amazon-DynamoDB_16.png
│ │ │ ├── Arch_Amazon-DynamoDB_16.svg
│ │ │ ├── Arch_Amazon-ElastiCache_16.png
│ │ │ ├── Arch_Amazon-ElastiCache_16.svg
│ │ │ ├── Arch_Amazon-Keyspaces_16.png
│ │ │ ├── Arch_Amazon-Keyspaces_16.svg
│ │ │ ├── Arch_Amazon-MemoryDB_16.png
│ │ │ ├── Arch_Amazon-MemoryDB_16.svg
│ │ │ ├── Arch_Amazon-Neptune_16.png
│ │ │ ├── Arch_Amazon-Neptune_16.svg
│ │ │ ├── Arch_Amazon-RDS_16.png
│ │ │ ├── Arch_Amazon-RDS_16.svg
│ │ │ ├── Arch_Amazon-Timestream_16.png
│ │ │ ├── Arch_Amazon-Timestream_16.svg
│ │ │ ├── Arch_AWS-Database-Migration-Service_16.png
│ │ │ ├── Arch_AWS-Database-Migration-Service_16.svg
│ │ │ ├── Arch_Oracle-Database-at-AWS_16.png
│ │ │ └── Arch_Oracle-Database-at-AWS_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Aurora_32.png
│ │ │ ├── Arch_Amazon-Aurora_32.svg
│ │ │ ├── Arch_Amazon-DocumentDB_32.png
│ │ │ ├── Arch_Amazon-DocumentDB_32.svg
│ │ │ ├── Arch_Amazon-DynamoDB_32.png
│ │ │ ├── Arch_Amazon-DynamoDB_32.svg
│ │ │ ├── Arch_Amazon-ElastiCache_32.png
│ │ │ ├── Arch_Amazon-ElastiCache_32.svg
│ │ │ ├── Arch_Amazon-Keyspaces_32.png
│ │ │ ├── Arch_Amazon-Keyspaces_32.svg
│ │ │ ├── Arch_Amazon-MemoryDB_32.png
│ │ │ ├── Arch_Amazon-MemoryDB_32.svg
│ │ │ ├── Arch_Amazon-Neptune_32.png
│ │ │ ├── Arch_Amazon-Neptune_32.svg
│ │ │ ├── Arch_Amazon-RDS_32.png
│ │ │ ├── Arch_Amazon-RDS_32.svg
│ │ │ ├── Arch_Amazon-Timestream_32.png
│ │ │ ├── Arch_Amazon-Timestream_32.svg
│ │ │ ├── Arch_AWS-Database-Migration-Service_32.png
│ │ │ ├── Arch_AWS-Database-Migration-Service_32.svg
│ │ │ ├── Arch_Oracle-Database-at-AWS_32.png
│ │ │ └── Arch_Oracle-Database-at-AWS_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Aurora_48.png
│ │ │ ├── Arch_Amazon-Aurora_48.svg
│ │ │ ├── Arch_Amazon-DocumentDB_48.png
│ │ │ ├── Arch_Amazon-DocumentDB_48.svg
│ │ │ ├── Arch_Amazon-DynamoDB_48.png
│ │ │ ├── Arch_Amazon-DynamoDB_48.svg
│ │ │ ├── Arch_Amazon-ElastiCache_48.png
│ │ │ ├── Arch_Amazon-ElastiCache_48.svg
│ │ │ ├── Arch_Amazon-Keyspaces_48.png
│ │ │ ├── Arch_Amazon-Keyspaces_48.svg
│ │ │ ├── Arch_Amazon-MemoryDB_48.png
│ │ │ ├── Arch_Amazon-MemoryDB_48.svg
│ │ │ ├── Arch_Amazon-Neptune_48.png
│ │ │ ├── Arch_Amazon-Neptune_48.svg
│ │ │ ├── Arch_Amazon-RDS_48.png
│ │ │ ├── Arch_Amazon-RDS_48.svg
│ │ │ ├── Arch_Amazon-Timestream_48.png
│ │ │ ├── Arch_Amazon-Timestream_48.svg
│ │ │ ├── Arch_AWS-Database-Migration-Service_48.png
│ │ │ ├── Arch_AWS-Database-Migration-Service_48.svg
│ │ │ ├── Arch_Oracle-Database-at-AWS_48.png
│ │ │ └── Arch_Oracle-Database-at-AWS_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Aurora_64.png
│ │ ├── Arch_Amazon-Aurora_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DocumentDB_64.png
│ │ ├── Arch_Amazon-DocumentDB_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-DynamoDB_64.png
│ │ ├── Arch_Amazon-DynamoDB_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-ElastiCache_64.png
│ │ ├── Arch_Amazon-ElastiCache_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Keyspaces_64.png
│ │ ├── Arch_Amazon-Keyspaces_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-MemoryDB_64.png
│ │ ├── Arch_Amazon-MemoryDB_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Neptune_64.png
│ │ ├── Arch_Amazon-Neptune_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-RDS_64.png
│ │ ├── Arch_Amazon-RDS_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Timestream_64.png
│ │ ├── Arch_Amazon-Timestream_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Database-Migration-Service_64.png
│ │ ├── Arch_AWS-Database-Migration-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Oracle-Database-at-AWS_64.png
│ │ ├── Arch_Oracle-Database-at-AWS_64.svg
│ │ └── [email protected]
│ ├── developer-tools
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CodeCatalyst_16.png
│ │ │ ├── Arch_Amazon-CodeCatalyst_16.svg
│ │ │ ├── Arch_Amazon-Corretto_16.png
│ │ │ ├── Arch_Amazon-Corretto_16.svg
│ │ │ ├── Arch_AWS-Cloud-Control-API_16.png
│ │ │ ├── Arch_AWS-Cloud-Control-API_16.svg
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_16.png
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_16.svg
│ │ │ ├── Arch_AWS-Cloud9_16.png
│ │ │ ├── Arch_AWS-Cloud9_16.svg
│ │ │ ├── Arch_AWS-CloudShell_16.png
│ │ │ ├── Arch_AWS-CloudShell_16.svg
│ │ │ ├── Arch_AWS-CodeArtifact_16.png
│ │ │ ├── Arch_AWS-CodeArtifact_16.svg
│ │ │ ├── Arch_AWS-CodeBuild_16.png
│ │ │ ├── Arch_AWS-CodeBuild_16.svg
│ │ │ ├── Arch_AWS-CodeCommit_16.png
│ │ │ ├── Arch_AWS-CodeCommit_16.svg
│ │ │ ├── Arch_AWS-CodeDeploy_16.png
│ │ │ ├── Arch_AWS-CodeDeploy_16.svg
│ │ │ ├── Arch_AWS-CodePipeline_16.png
│ │ │ ├── Arch_AWS-CodePipeline_16.svg
│ │ │ ├── Arch_AWS-Command-Line-Interface_16.png
│ │ │ ├── Arch_AWS-Command-Line-Interface_16.svg
│ │ │ ├── Arch_AWS-Fault-Injection-Service_16.png
│ │ │ ├── Arch_AWS-Fault-Injection-Service_16.svg
│ │ │ ├── Arch_AWS-Infrastructure-Composer_16.png
│ │ │ ├── Arch_AWS-Infrastructure-Composer_16.svg
│ │ │ ├── Arch_AWS-Tools-and-SDKs_16.png
│ │ │ ├── Arch_AWS-Tools-and-SDKs_16.svg
│ │ │ ├── Arch_AWS-X-Ray_16.png
│ │ │ └── Arch_AWS-X-Ray_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CodeCatalyst_32.png
│ │ │ ├── Arch_Amazon-CodeCatalyst_32.svg
│ │ │ ├── Arch_Amazon-Corretto_32.png
│ │ │ ├── Arch_Amazon-Corretto_32.svg
│ │ │ ├── Arch_AWS-Cloud-Control-API_32.png
│ │ │ ├── Arch_AWS-Cloud-Control-API_32.svg
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_32.png
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_32.svg
│ │ │ ├── Arch_AWS-Cloud9_32.png
│ │ │ ├── Arch_AWS-Cloud9_32.svg
│ │ │ ├── Arch_AWS-CloudShell_32.png
│ │ │ ├── Arch_AWS-CloudShell_32.svg
│ │ │ ├── Arch_AWS-CodeArtifact_32.png
│ │ │ ├── Arch_AWS-CodeArtifact_32.svg
│ │ │ ├── Arch_AWS-CodeBuild_32.png
│ │ │ ├── Arch_AWS-CodeBuild_32.svg
│ │ │ ├── Arch_AWS-CodeCommit_32.png
│ │ │ ├── Arch_AWS-CodeCommit_32.svg
│ │ │ ├── Arch_AWS-CodeDeploy_32.png
│ │ │ ├── Arch_AWS-CodeDeploy_32.svg
│ │ │ ├── Arch_AWS-CodePipeline_32.png
│ │ │ ├── Arch_AWS-CodePipeline_32.svg
│ │ │ ├── Arch_AWS-Command-Line-Interface_32.png
│ │ │ ├── Arch_AWS-Command-Line-Interface_32.svg
│ │ │ ├── Arch_AWS-Fault-Injection-Service_32.png
│ │ │ ├── Arch_AWS-Fault-Injection-Service_32.svg
│ │ │ ├── Arch_AWS-Infrastructure-Composer_32.png
│ │ │ ├── Arch_AWS-Infrastructure-Composer_32.svg
│ │ │ ├── Arch_AWS-Tools-and-SDKs_32.png
│ │ │ ├── Arch_AWS-Tools-and-SDKs_32.svg
│ │ │ ├── Arch_AWS-X-Ray_32.png
│ │ │ └── Arch_AWS-X-Ray_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CodeCatalyst_48.png
│ │ │ ├── Arch_Amazon-CodeCatalyst_48.svg
│ │ │ ├── Arch_Amazon-Corretto_48.png
│ │ │ ├── Arch_Amazon-Corretto_48.svg
│ │ │ ├── Arch_AWS-Cloud-Control-API_48.png
│ │ │ ├── Arch_AWS-Cloud-Control-API_48.svg
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_48.png
│ │ │ ├── Arch_AWS-Cloud-Development-Kit_48.svg
│ │ │ ├── Arch_AWS-Cloud9_48.png
│ │ │ ├── Arch_AWS-Cloud9_48.svg
│ │ │ ├── Arch_AWS-CloudShell_48.png
│ │ │ ├── Arch_AWS-CloudShell_48.svg
│ │ │ ├── Arch_AWS-CodeArtifact_48.png
│ │ │ ├── Arch_AWS-CodeArtifact_48.svg
│ │ │ ├── Arch_AWS-CodeBuild_48.png
│ │ │ ├── Arch_AWS-CodeBuild_48.svg
│ │ │ ├── Arch_AWS-CodeCommit_48.png
│ │ │ ├── Arch_AWS-CodeCommit_48.svg
│ │ │ ├── Arch_AWS-CodeDeploy_48.png
│ │ │ ├── Arch_AWS-CodeDeploy_48.svg
│ │ │ ├── Arch_AWS-CodePipeline_48.png
│ │ │ ├── Arch_AWS-CodePipeline_48.svg
│ │ │ ├── Arch_AWS-Command-Line-Interface_48.png
│ │ │ ├── Arch_AWS-Command-Line-Interface_48.svg
│ │ │ ├── Arch_AWS-Fault-Injection-Service_48.png
│ │ │ ├── Arch_AWS-Fault-Injection-Service_48.svg
│ │ │ ├── Arch_AWS-Infrastructure-Composer_48.png
│ │ │ ├── Arch_AWS-Infrastructure-Composer_48.svg
│ │ │ ├── Arch_AWS-Tools-and-SDKs_48.png
│ │ │ ├── Arch_AWS-Tools-and-SDKs_48.svg
│ │ │ ├── Arch_AWS-X-Ray_48.png
│ │ │ └── Arch_AWS-X-Ray_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-CodeCatalyst_64.png
│ │ ├── Arch_Amazon-CodeCatalyst_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Corretto_64.png
│ │ ├── Arch_Amazon-Corretto_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-Control-API_64.png
│ │ ├── Arch_AWS-Cloud-Control-API_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-Development-Kit_64.png
│ │ ├── Arch_AWS-Cloud-Development-Kit_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud9_64.png
│ │ ├── Arch_AWS-Cloud9_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudShell_64.png
│ │ ├── Arch_AWS-CloudShell_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeArtifact_64.png
│ │ ├── Arch_AWS-CodeArtifact_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeBuild_64.png
│ │ ├── Arch_AWS-CodeBuild_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeCommit_64.png
│ │ ├── Arch_AWS-CodeCommit_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodeDeploy_64.png
│ │ ├── Arch_AWS-CodeDeploy_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CodePipeline_64.png
│ │ ├── Arch_AWS-CodePipeline_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Command-Line-Interface_64.png
│ │ ├── Arch_AWS-Command-Line-Interface_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Fault-Injection-Service_64.png
│ │ ├── Arch_AWS-Fault-Injection-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Infrastructure-Composer_64.png
│ │ ├── Arch_AWS-Infrastructure-Composer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Tools-and-SDKs_64.png
│ │ ├── Arch_AWS-Tools-and-SDKs_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-X-Ray_64.png
│ │ ├── Arch_AWS-X-Ray_64.svg
│ │ └── [email protected]
│ ├── end-user-computing
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppStream-2_16.png
│ │ │ ├── Arch_Amazon-AppStream-2_16.svg
│ │ │ ├── Arch_Amazon-WorkSpaces-Family_16.png
│ │ │ └── Arch_Amazon-WorkSpaces-Family_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppStream-2_32.png
│ │ │ ├── Arch_Amazon-AppStream-2_32.svg
│ │ │ ├── Arch_Amazon-WorkSpaces-Family_32.png
│ │ │ └── Arch_Amazon-WorkSpaces-Family_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-AppStream-2_48.png
│ │ │ ├── Arch_Amazon-AppStream-2_48.svg
│ │ │ ├── Arch_Amazon-WorkSpaces-Family_48.png
│ │ │ └── Arch_Amazon-WorkSpaces-Family_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-AppStream-2_64.png
│ │ ├── Arch_Amazon-AppStream-2_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-WorkSpaces-Family_64.png
│ │ ├── Arch_Amazon-WorkSpaces-Family_64.svg
│ │ └── [email protected]
│ ├── front-end-web-mobile
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Location-Service_16.png
│ │ │ ├── Arch_Amazon-Location-Service_16.svg
│ │ │ ├── Arch_AWS-Amplify_16.png
│ │ │ ├── Arch_AWS-Amplify_16.svg
│ │ │ ├── Arch_AWS-Device-Farm_16.png
│ │ │ └── Arch_AWS-Device-Farm_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Location-Service_32.png
│ │ │ ├── Arch_Amazon-Location-Service_32.svg
│ │ │ ├── Arch_AWS-Amplify_32.png
│ │ │ ├── Arch_AWS-Amplify_32.svg
│ │ │ ├── Arch_AWS-Device-Farm_32.png
│ │ │ └── Arch_AWS-Device-Farm_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Location-Service_48.png
│ │ │ ├── Arch_Amazon-Location-Service_48.svg
│ │ │ ├── Arch_AWS-Amplify_48.png
│ │ │ ├── Arch_AWS-Amplify_48.svg
│ │ │ ├── Arch_AWS-Device-Farm_48.png
│ │ │ └── Arch_AWS-Device-Farm_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Location-Service_64.png
│ │ ├── Arch_Amazon-Location-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Amplify_64.png
│ │ ├── Arch_AWS-Amplify_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Device-Farm_64.png
│ │ ├── Arch_AWS-Device-Farm_64.svg
│ │ └── [email protected]
│ ├── games
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-GameLift-Servers_16.png
│ │ │ ├── Arch_Amazon-GameLift-Servers_16.svg
│ │ │ ├── Arch_Amazon-GameLift-Streams_16.png
│ │ │ ├── Arch_Amazon-GameLift-Streams_16.svg
│ │ │ ├── Arch_Open-3D-Engine_16.png
│ │ │ └── Arch_Open-3D-Engine_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-GameLift-Servers_32.png
│ │ │ ├── Arch_Amazon-GameLift-Servers_32.svg
│ │ │ ├── Arch_Amazon-GameLift-Streams_32.png
│ │ │ ├── Arch_Amazon-GameLift-Streams_32.svg
│ │ │ ├── Arch_Open-3D-Engine_32.png
│ │ │ └── Arch_Open-3D-Engine_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-GameLift-Servers_48.png
│ │ │ ├── Arch_Amazon-GameLift-Servers_48.svg
│ │ │ ├── Arch_Amazon-GameLift-Streams_48.png
│ │ │ ├── Arch_Amazon-GameLift-Streams_48.svg
│ │ │ ├── Arch_Open-3D-Engine_48.png
│ │ │ └── Arch_Open-3D-Engine_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-GameLift-Servers_64.png
│ │ ├── Arch_Amazon-GameLift-Servers_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-GameLift-Streams_64.png
│ │ ├── Arch_Amazon-GameLift-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Open-3D-Engine_64.png
│ │ ├── Arch_Open-3D-Engine_64.svg
│ │ └── [email protected]
│ ├── general-icons
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_AWS-Marketplace_Dark_16.png
│ │ │ ├── Arch_AWS-Marketplace_Dark_16.svg
│ │ │ ├── Arch_AWS-Marketplace_Light_16.png
│ │ │ └── Arch_AWS-Marketplace_Light_16.svg
│ │ ├── 32
│ │ │ ├── Arch_AWS-Marketplace_Dark_32.png
│ │ │ ├── Arch_AWS-Marketplace_Dark_32.svg
│ │ │ ├── Arch_AWS-Marketplace_Light_32.png
│ │ │ └── Arch_AWS-Marketplace_Light_32.svg
│ │ ├── 48
│ │ │ ├── Arch_AWS-Marketplace_Dark_48.png
│ │ │ ├── Arch_AWS-Marketplace_Dark_48.svg
│ │ │ ├── Arch_AWS-Marketplace_Light_48.png
│ │ │ └── Arch_AWS-Marketplace_Light_48.svg
│ │ └── 64
│ │ ├── Arch_AWS-Marketplace_Dark_64.png
│ │ ├── Arch_AWS-Marketplace_Dark_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Marketplace_Light_64.png
│ │ ├── Arch_AWS-Marketplace_Light_64.svg
│ │ └── [email protected]
│ ├── internet-of-things
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-IoT-Analytics_16.png
│ │ │ ├── Arch_AWS-IoT-Analytics_16.svg
│ │ │ ├── Arch_AWS-IoT-Button_16.png
│ │ │ ├── Arch_AWS-IoT-Button_16.svg
│ │ │ ├── Arch_AWS-IoT-Core_16.png
│ │ │ ├── Arch_AWS-IoT-Core_16.svg
│ │ │ ├── Arch_AWS-IoT-Device-Defender_16.png
│ │ │ ├── Arch_AWS-IoT-Device-Defender_16.svg
│ │ │ ├── Arch_AWS-IoT-Device-Management_16.png
│ │ │ ├── Arch_AWS-IoT-Device-Management_16.svg
│ │ │ ├── Arch_AWS-IoT-Events_16.png
│ │ │ ├── Arch_AWS-IoT-Events_16.svg
│ │ │ ├── Arch_AWS-IoT-ExpressLink_16.png
│ │ │ ├── Arch_AWS-IoT-ExpressLink_16.svg
│ │ │ ├── Arch_AWS-IoT-FleetWise_16.png
│ │ │ ├── Arch_AWS-IoT-FleetWise_16.svg
│ │ │ ├── Arch_AWS-IoT-Greengrass_16.png
│ │ │ ├── Arch_AWS-IoT-Greengrass_16.svg
│ │ │ ├── Arch_AWS-IoT-SiteWise_16.png
│ │ │ ├── Arch_AWS-IoT-SiteWise_16.svg
│ │ │ ├── Arch_AWS-IoT-TwinMaker_16.png
│ │ │ ├── Arch_AWS-IoT-TwinMaker_16.svg
│ │ │ ├── Arch_FreeRTOS_16.png
│ │ │ └── Arch_FreeRTOS_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-IoT-Analytics_32.png
│ │ │ ├── Arch_AWS-IoT-Analytics_32.svg
│ │ │ ├── Arch_AWS-IoT-Button_32.png
│ │ │ ├── Arch_AWS-IoT-Button_32.svg
│ │ │ ├── Arch_AWS-IoT-Core_32.png
│ │ │ ├── Arch_AWS-IoT-Core_32.svg
│ │ │ ├── Arch_AWS-IoT-Device-Defender_32.png
│ │ │ ├── Arch_AWS-IoT-Device-Defender_32.svg
│ │ │ ├── Arch_AWS-IoT-Device-Management_32.png
│ │ │ ├── Arch_AWS-IoT-Device-Management_32.svg
│ │ │ ├── Arch_AWS-IoT-Events_32.png
│ │ │ ├── Arch_AWS-IoT-Events_32.svg
│ │ │ ├── Arch_AWS-IoT-ExpressLink_32.png
│ │ │ ├── Arch_AWS-IoT-ExpressLink_32.svg
│ │ │ ├── Arch_AWS-IoT-FleetWise_32.png
│ │ │ ├── Arch_AWS-IoT-FleetWise_32.svg
│ │ │ ├── Arch_AWS-IoT-Greengrass_32.png
│ │ │ ├── Arch_AWS-IoT-Greengrass_32.svg
│ │ │ ├── Arch_AWS-IoT-SiteWise_32.png
│ │ │ ├── Arch_AWS-IoT-SiteWise_32.svg
│ │ │ ├── Arch_AWS-IoT-TwinMaker_32.png
│ │ │ ├── Arch_AWS-IoT-TwinMaker_32.svg
│ │ │ ├── Arch_FreeRTOS_32.png
│ │ │ └── Arch_FreeRTOS_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-IoT-Analytics_48.png
│ │ │ ├── Arch_AWS-IoT-Analytics_48.svg
│ │ │ ├── Arch_AWS-IoT-Button_48.png
│ │ │ ├── Arch_AWS-IoT-Button_48.svg
│ │ │ ├── Arch_AWS-IoT-Core_48.png
│ │ │ ├── Arch_AWS-IoT-Core_48.svg
│ │ │ ├── Arch_AWS-IoT-Device-Defender_48.png
│ │ │ ├── Arch_AWS-IoT-Device-Defender_48.svg
│ │ │ ├── Arch_AWS-IoT-Device-Management_48.png
│ │ │ ├── Arch_AWS-IoT-Device-Management_48.svg
│ │ │ ├── Arch_AWS-IoT-Events_48.png
│ │ │ ├── Arch_AWS-IoT-Events_48.svg
│ │ │ ├── Arch_AWS-IoT-ExpressLink_48.png
│ │ │ ├── Arch_AWS-IoT-ExpressLink_48.svg
│ │ │ ├── Arch_AWS-IoT-FleetWise_48.png
│ │ │ ├── Arch_AWS-IoT-FleetWise_48.svg
│ │ │ ├── Arch_AWS-IoT-Greengrass_48.png
│ │ │ ├── Arch_AWS-IoT-Greengrass_48.svg
│ │ │ ├── Arch_AWS-IoT-SiteWise_48.png
│ │ │ ├── Arch_AWS-IoT-SiteWise_48.svg
│ │ │ ├── Arch_AWS-IoT-TwinMaker_48.png
│ │ │ ├── Arch_AWS-IoT-TwinMaker_48.svg
│ │ │ ├── Arch_FreeRTOS_48.png
│ │ │ └── Arch_FreeRTOS_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_AWS-IoT-Analytics_64.png
│ │ ├── Arch_AWS-IoT-Analytics_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Button_64.png
│ │ ├── Arch_AWS-IoT-Button_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Core_64.png
│ │ ├── Arch_AWS-IoT-Core_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Device-Defender_64.png
│ │ ├── Arch_AWS-IoT-Device-Defender_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Device-Management_64.png
│ │ ├── Arch_AWS-IoT-Device-Management_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Events_64.png
│ │ ├── Arch_AWS-IoT-Events_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-ExpressLink_64.png
│ │ ├── Arch_AWS-IoT-ExpressLink_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-FleetWise_64.png
│ │ ├── Arch_AWS-IoT-FleetWise_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-Greengrass_64.png
│ │ ├── Arch_AWS-IoT-Greengrass_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-SiteWise_64.png
│ │ ├── Arch_AWS-IoT-SiteWise_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IoT-TwinMaker_64.png
│ │ ├── Arch_AWS-IoT-TwinMaker_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_FreeRTOS_64.png
│ │ ├── Arch_FreeRTOS_64.svg
│ │ └── [email protected]
│ ├── management-governance
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CloudWatch_16.png
│ │ │ ├── Arch_Amazon-CloudWatch_16.svg
│ │ │ ├── Arch_Amazon-Managed-Grafana_16.png
│ │ │ ├── Arch_Amazon-Managed-Grafana_16.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_16.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_16.svg
│ │ │ ├── Arch_AWS-AppConfig_16.png
│ │ │ ├── Arch_AWS-AppConfig_16.svg
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_16.png
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_16.svg
│ │ │ ├── Arch_AWS-Auto-Scaling_16.png
│ │ │ ├── Arch_AWS-Auto-Scaling_16.svg
│ │ │ ├── Arch_AWS-Backint-Agent_16.png
│ │ │ ├── Arch_AWS-Backint-Agent_16.svg
│ │ │ ├── Arch_AWS-Chatbot_16.png
│ │ │ ├── Arch_AWS-Chatbot_16.svg
│ │ │ ├── Arch_AWS-CloudFormation_16.png
│ │ │ ├── Arch_AWS-CloudFormation_16.svg
│ │ │ ├── Arch_AWS-CloudTrail_16.png
│ │ │ ├── Arch_AWS-CloudTrail_16.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_16.svg
│ │ │ ├── Arch_AWS-Config_16.png
│ │ │ ├── Arch_AWS-Config_16.svg
│ │ │ ├── Arch_AWS-Console-Mobile-Application_16.png
│ │ │ ├── Arch_AWS-Console-Mobile-Application_16.svg
│ │ │ ├── Arch_AWS-Control-Tower_16.png
│ │ │ ├── Arch_AWS-Control-Tower_16.svg
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_16.png
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_16.svg
│ │ │ ├── Arch_AWS-Health-Dashboard_16.png
│ │ │ ├── Arch_AWS-Health-Dashboard_16.svg
│ │ │ ├── Arch_AWS-Launch-Wizard_16.png
│ │ │ ├── Arch_AWS-Launch-Wizard_16.svg
│ │ │ ├── Arch_AWS-License-Manager_16.png
│ │ │ ├── Arch_AWS-License-Manager_16.svg
│ │ │ ├── Arch_AWS-Management-Console_16.png
│ │ │ ├── Arch_AWS-Management-Console_16.svg
│ │ │ ├── Arch_AWS-Organizations_16.png
│ │ │ ├── Arch_AWS-Organizations_16.svg
│ │ │ ├── Arch_AWS-Proton_16.png
│ │ │ ├── Arch_AWS-Proton_16.svg
│ │ │ ├── Arch_AWS-Resilience-Hub_16.png
│ │ │ ├── Arch_AWS-Resilience-Hub_16.svg
│ │ │ ├── Arch_AWS-Resource-Explorer_16.png
│ │ │ ├── Arch_AWS-Resource-Explorer_16.svg
│ │ │ ├── Arch_AWS-Service-Catalog_16.png
│ │ │ ├── Arch_AWS-Service-Catalog_16.svg
│ │ │ ├── Arch_AWS-Service-Management-Connector_16.png
│ │ │ ├── Arch_AWS-Service-Management-Connector_16.svg
│ │ │ ├── Arch_AWS-Systems-Manager_16.png
│ │ │ ├── Arch_AWS-Systems-Manager_16.svg
│ │ │ ├── Arch_AWS-Telco-Network-Builder_16.png
│ │ │ ├── Arch_AWS-Telco-Network-Builder_16.svg
│ │ │ ├── Arch_AWS-Trusted-Advisor_16.png
│ │ │ ├── Arch_AWS-Trusted-Advisor_16.svg
│ │ │ ├── Arch_AWS-User-Notifications_16.png
│ │ │ ├── Arch_AWS-User-Notifications_16.svg
│ │ │ ├── Arch_AWS-Well-Architected-Tool_16.png
│ │ │ └── Arch_AWS-Well-Architected-Tool_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CloudWatch_32.png
│ │ │ ├── Arch_Amazon-CloudWatch_32.svg
│ │ │ ├── Arch_Amazon-Managed-Grafana_32.png
│ │ │ ├── Arch_Amazon-Managed-Grafana_32.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_32.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_32.svg
│ │ │ ├── Arch_AWS-AppConfig_32.png
│ │ │ ├── Arch_AWS-AppConfig_32.svg
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_32.png
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_32.svg
│ │ │ ├── Arch_AWS-Auto-Scaling_32.png
│ │ │ ├── Arch_AWS-Auto-Scaling_32.svg
│ │ │ ├── Arch_AWS-Backint-Agent_32.png
│ │ │ ├── Arch_AWS-Backint-Agent_32.svg
│ │ │ ├── Arch_AWS-Chatbot_32.png
│ │ │ ├── Arch_AWS-Chatbot_32.svg
│ │ │ ├── Arch_AWS-CloudFormation_32.png
│ │ │ ├── Arch_AWS-CloudFormation_32.svg
│ │ │ ├── Arch_AWS-CloudTrail_32.png
│ │ │ ├── Arch_AWS-CloudTrail_32.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_32.svg
│ │ │ ├── Arch_AWS-Config_32.png
│ │ │ ├── Arch_AWS-Config_32.svg
│ │ │ ├── Arch_AWS-Console-Mobile-Application_32.png
│ │ │ ├── Arch_AWS-Console-Mobile-Application_32.svg
│ │ │ ├── Arch_AWS-Control-Tower_32.png
│ │ │ ├── Arch_AWS-Control-Tower_32.svg
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_32.png
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_32.svg
│ │ │ ├── Arch_AWS-Health-Dashboard_32.png
│ │ │ ├── Arch_AWS-Health-Dashboard_32.svg
│ │ │ ├── Arch_AWS-Launch-Wizard_32.png
│ │ │ ├── Arch_AWS-Launch-Wizard_32.svg
│ │ │ ├── Arch_AWS-License-Manager_32.png
│ │ │ ├── Arch_AWS-License-Manager_32.svg
│ │ │ ├── Arch_AWS-Management-Console_32.png
│ │ │ ├── Arch_AWS-Management-Console_32.svg
│ │ │ ├── Arch_AWS-Organizations_32.png
│ │ │ ├── Arch_AWS-Organizations_32.svg
│ │ │ ├── Arch_AWS-Proton_32.png
│ │ │ ├── Arch_AWS-Proton_32.svg
│ │ │ ├── Arch_AWS-Resilience-Hub_32.png
│ │ │ ├── Arch_AWS-Resilience-Hub_32.svg
│ │ │ ├── Arch_AWS-Resource-Explorer_32.png
│ │ │ ├── Arch_AWS-Resource-Explorer_32.svg
│ │ │ ├── Arch_AWS-Service-Catalog_32.png
│ │ │ ├── Arch_AWS-Service-Catalog_32.svg
│ │ │ ├── Arch_AWS-Service-Management-Connector_32.png
│ │ │ ├── Arch_AWS-Service-Management-Connector_32.svg
│ │ │ ├── Arch_AWS-Systems-Manager_32.png
│ │ │ ├── Arch_AWS-Systems-Manager_32.svg
│ │ │ ├── Arch_AWS-Telco-Network-Builder_32.png
│ │ │ ├── Arch_AWS-Telco-Network-Builder_32.svg
│ │ │ ├── Arch_AWS-Trusted-Advisor_32.png
│ │ │ ├── Arch_AWS-Trusted-Advisor_32.svg
│ │ │ ├── Arch_AWS-User-Notifications_32.png
│ │ │ ├── Arch_AWS-User-Notifications_32.svg
│ │ │ ├── Arch_AWS-Well-Architected-Tool_32.png
│ │ │ └── Arch_AWS-Well-Architected-Tool_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-CloudWatch_48.png
│ │ │ ├── Arch_Amazon-CloudWatch_48.svg
│ │ │ ├── Arch_Amazon-Managed-Grafana_48.png
│ │ │ ├── Arch_Amazon-Managed-Grafana_48.svg
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_48.png
│ │ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_48.svg
│ │ │ ├── Arch_AWS-AppConfig_48.png
│ │ │ ├── Arch_AWS-AppConfig_48.svg
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_48.png
│ │ │ ├── Arch_AWS-Application-Auto-Scaling_48.svg
│ │ │ ├── Arch_AWS-Auto-Scaling_48.png
│ │ │ ├── Arch_AWS-Auto-Scaling_48.svg
│ │ │ ├── Arch_AWS-Backint-Agent_48.png
│ │ │ ├── Arch_AWS-Backint-Agent_48.svg
│ │ │ ├── Arch_AWS-Chatbot_48.png
│ │ │ ├── Arch_AWS-Chatbot_48.svg
│ │ │ ├── Arch_AWS-CloudFormation_48.png
│ │ │ ├── Arch_AWS-CloudFormation_48.svg
│ │ │ ├── Arch_AWS-CloudTrail_48.png
│ │ │ ├── Arch_AWS-CloudTrail_48.svg
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.png
│ │ │ ├── Arch_AWS-Compute-Optimizer_48.svg
│ │ │ ├── Arch_AWS-Config_48.png
│ │ │ ├── Arch_AWS-Config_48.svg
│ │ │ ├── Arch_AWS-Console-Mobile-Application_48.png
│ │ │ ├── Arch_AWS-Console-Mobile-Application_48.svg
│ │ │ ├── Arch_AWS-Control-Tower_48.png
│ │ │ ├── Arch_AWS-Control-Tower_48.svg
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_48.png
│ │ │ ├── Arch_AWS-Distro-for-OpenTelemetry_48.svg
│ │ │ ├── Arch_AWS-Health-Dashboard_48.png
│ │ │ ├── Arch_AWS-Health-Dashboard_48.svg
│ │ │ ├── Arch_AWS-Launch-Wizard_48.png
│ │ │ ├── Arch_AWS-Launch-Wizard_48.svg
│ │ │ ├── Arch_AWS-License-Manager_48.png
│ │ │ ├── Arch_AWS-License-Manager_48.svg
│ │ │ ├── Arch_AWS-Management-Console_48.png
│ │ │ ├── Arch_AWS-Management-Console_48.svg
│ │ │ ├── Arch_AWS-Organizations_48.png
│ │ │ ├── Arch_AWS-Organizations_48.svg
│ │ │ ├── Arch_AWS-Proton_48.png
│ │ │ ├── Arch_AWS-Proton_48.svg
│ │ │ ├── Arch_AWS-Resilience-Hub_48.png
│ │ │ ├── Arch_AWS-Resilience-Hub_48.svg
│ │ │ ├── Arch_AWS-Resource-Explorer_48.png
│ │ │ ├── Arch_AWS-Resource-Explorer_48.svg
│ │ │ ├── Arch_AWS-Service-Catalog_48.png
│ │ │ ├── Arch_AWS-Service-Catalog_48.svg
│ │ │ ├── Arch_AWS-Service-Management-Connector_48.png
│ │ │ ├── Arch_AWS-Service-Management-Connector_48.svg
│ │ │ ├── Arch_AWS-Systems-Manager_48.png
│ │ │ ├── Arch_AWS-Systems-Manager_48.svg
│ │ │ ├── Arch_AWS-Telco-Network-Builder_48.png
│ │ │ ├── Arch_AWS-Telco-Network-Builder_48.svg
│ │ │ ├── Arch_AWS-Trusted-Advisor_48.png
│ │ │ ├── Arch_AWS-Trusted-Advisor_48.svg
│ │ │ ├── Arch_AWS-User-Notifications_48.png
│ │ │ ├── Arch_AWS-User-Notifications_48.svg
│ │ │ ├── Arch_AWS-Well-Architected-Tool_48.png
│ │ │ └── Arch_AWS-Well-Architected-Tool_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-CloudWatch_64.png
│ │ ├── Arch_Amazon-CloudWatch_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Grafana_64.png
│ │ ├── Arch_Amazon-Managed-Grafana_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_64.png
│ │ ├── Arch_Amazon-Managed-Service-for-Prometheus_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-AppConfig_64.png
│ │ ├── Arch_AWS-AppConfig_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Application-Auto-Scaling_64.png
│ │ ├── Arch_AWS-Application-Auto-Scaling_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Auto-Scaling_64.png
│ │ ├── Arch_AWS-Auto-Scaling_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Backint-Agent_64.png
│ │ ├── Arch_AWS-Backint-Agent_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Chatbot_64.png
│ │ ├── Arch_AWS-Chatbot_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudFormation_64.png
│ │ ├── Arch_AWS-CloudFormation_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudTrail_64.png
│ │ ├── Arch_AWS-CloudTrail_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Compute-Optimizer_64.png
│ │ ├── Arch_AWS-Compute-Optimizer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Config_64.png
│ │ ├── Arch_AWS-Config_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Console-Mobile-Application_64.png
│ │ ├── Arch_AWS-Console-Mobile-Application_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Control-Tower_64.png
│ │ ├── Arch_AWS-Control-Tower_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Distro-for-OpenTelemetry_64.png
│ │ ├── Arch_AWS-Distro-for-OpenTelemetry_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Health-Dashboard_64.png
│ │ ├── Arch_AWS-Health-Dashboard_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Launch-Wizard_64.png
│ │ ├── Arch_AWS-Launch-Wizard_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-License-Manager_64.png
│ │ ├── Arch_AWS-License-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Management-Console_64.png
│ │ ├── Arch_AWS-Management-Console_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Organizations_64.png
│ │ ├── Arch_AWS-Organizations_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Proton_64.png
│ │ ├── Arch_AWS-Proton_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Resilience-Hub_64.png
│ │ ├── Arch_AWS-Resilience-Hub_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Resource-Explorer_64.png
│ │ ├── Arch_AWS-Resource-Explorer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Service-Catalog_64.png
│ │ ├── Arch_AWS-Service-Catalog_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Service-Management-Connector_64.png
│ │ ├── Arch_AWS-Service-Management-Connector_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Systems-Manager_64.png
│ │ ├── Arch_AWS-Systems-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Telco-Network-Builder_64.png
│ │ ├── Arch_AWS-Telco-Network-Builder_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Trusted-Advisor_64.png
│ │ ├── Arch_AWS-Trusted-Advisor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-User-Notifications_64.png
│ │ ├── Arch_AWS-User-Notifications_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Well-Architected-Tool_64.png
│ │ ├── Arch_AWS-Well-Architected-Tool_64.svg
│ │ └── [email protected]
│ ├── media-services
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_16.png
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_16.svg
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_16.png
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_16.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_16.svg
│ │ │ ├── Arch_AWS-Deadline-Cloud_16.png
│ │ │ ├── Arch_AWS-Deadline-Cloud_16.svg
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_16.png
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_16.svg
│ │ │ ├── Arch_AWS-Elemental-Conductor_16.png
│ │ │ ├── Arch_AWS-Elemental-Conductor_16.svg
│ │ │ ├── Arch_AWS-Elemental-Delta_16.png
│ │ │ ├── Arch_AWS-Elemental-Delta_16.svg
│ │ │ ├── Arch_AWS-Elemental-Link_16.png
│ │ │ ├── Arch_AWS-Elemental-Link_16.svg
│ │ │ ├── Arch_AWS-Elemental-Live_16.png
│ │ │ ├── Arch_AWS-Elemental-Live_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaLive_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaLive_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaStore_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaStore_16.svg
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_16.png
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_16.svg
│ │ │ ├── Arch_AWS-Elemental-Server_16.png
│ │ │ ├── Arch_AWS-Elemental-Server_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Frost_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Frost_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_16.png
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_16.svg
│ │ │ ├── Arch_AWS-Thinkbox-XMesh_16.png
│ │ │ └── Arch_AWS-Thinkbox-XMesh_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_32.png
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_32.svg
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_32.png
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_32.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_32.svg
│ │ │ ├── Arch_AWS-Deadline-Cloud_32.png
│ │ │ ├── Arch_AWS-Deadline-Cloud_32.svg
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_32.png
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_32.svg
│ │ │ ├── Arch_AWS-Elemental-Conductor_32.png
│ │ │ ├── Arch_AWS-Elemental-Conductor_32.svg
│ │ │ ├── Arch_AWS-Elemental-Delta_32.png
│ │ │ ├── Arch_AWS-Elemental-Delta_32.svg
│ │ │ ├── Arch_AWS-Elemental-Link_32.png
│ │ │ ├── Arch_AWS-Elemental-Link_32.svg
│ │ │ ├── Arch_AWS-Elemental-Live_32.png
│ │ │ ├── Arch_AWS-Elemental-Live_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaLive_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaLive_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaStore_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaStore_32.svg
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_32.png
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_32.svg
│ │ │ ├── Arch_AWS-Elemental-Server_32.png
│ │ │ ├── Arch_AWS-Elemental-Server_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Frost_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Frost_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_32.png
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_32.svg
│ │ │ ├── Arch_AWS-Thinkbox-XMesh_32.png
│ │ │ └── Arch_AWS-Thinkbox-XMesh_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_48.png
│ │ │ ├── Arch_Amazon-Elastic-Transcoder_48.svg
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_48.png
│ │ │ ├── Arch_Amazon-Interactive-Video-Service_48.svg
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.png
│ │ │ ├── Arch_Amazon-Kinesis-Video-Streams_48.svg
│ │ │ ├── Arch_AWS-Deadline-Cloud_48.png
│ │ │ ├── Arch_AWS-Deadline-Cloud_48.svg
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_48.png
│ │ │ ├── Arch_AWS-Elemental-Appliances-&-Software_48.svg
│ │ │ ├── Arch_AWS-Elemental-Conductor_48.png
│ │ │ ├── Arch_AWS-Elemental-Conductor_48.svg
│ │ │ ├── Arch_AWS-Elemental-Delta_48.png
│ │ │ ├── Arch_AWS-Elemental-Delta_48.svg
│ │ │ ├── Arch_AWS-Elemental-Link_48.png
│ │ │ ├── Arch_AWS-Elemental-Link_48.svg
│ │ │ ├── Arch_AWS-Elemental-Live_48.png
│ │ │ ├── Arch_AWS-Elemental-Live_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaConnect_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaConvert_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaLive_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaLive_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaPackage_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaStore_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaStore_48.svg
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_48.png
│ │ │ ├── Arch_AWS-Elemental-MediaTailor_48.svg
│ │ │ ├── Arch_AWS-Elemental-Server_48.png
│ │ │ ├── Arch_AWS-Elemental-Server_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Deadline_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Frost_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Frost_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Krakatoa_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Sequoia_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_48.png
│ │ │ ├── Arch_AWS-Thinkbox-Stoke_48.svg
│ │ │ ├── Arch_AWS-Thinkbox-XMesh_48.png
│ │ │ └── Arch_AWS-Thinkbox-XMesh_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-Elastic-Transcoder_64.png
│ │ ├── Arch_Amazon-Elastic-Transcoder_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Interactive-Video-Service_64.png
│ │ ├── Arch_Amazon-Interactive-Video-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.png
│ │ ├── Arch_Amazon-Kinesis-Video-Streams_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Deadline-Cloud_64.png
│ │ ├── Arch_AWS-Deadline-Cloud_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Appliances-&-Software_64.png
│ │ ├── Arch_AWS-Elemental-Appliances-&-Software_64.svg
│ │ ├── Arch_AWS-Elemental-Appliances-&[email protected]
│ │ ├── Arch_AWS-Elemental-Conductor_64.png
│ │ ├── Arch_AWS-Elemental-Conductor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Delta_64.png
│ │ ├── Arch_AWS-Elemental-Delta_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Link_64.png
│ │ ├── Arch_AWS-Elemental-Link_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Live_64.png
│ │ ├── Arch_AWS-Elemental-Live_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaConnect_64.png
│ │ ├── Arch_AWS-Elemental-MediaConnect_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaConvert_64.png
│ │ ├── Arch_AWS-Elemental-MediaConvert_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaLive_64.png
│ │ ├── Arch_AWS-Elemental-MediaLive_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaPackage_64.png
│ │ ├── Arch_AWS-Elemental-MediaPackage_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaStore_64.png
│ │ ├── Arch_AWS-Elemental-MediaStore_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-MediaTailor_64.png
│ │ ├── Arch_AWS-Elemental-MediaTailor_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Elemental-Server_64.png
│ │ ├── Arch_AWS-Elemental-Server_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Deadline_64.png
│ │ ├── Arch_AWS-Thinkbox-Deadline_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Frost_64.png
│ │ ├── Arch_AWS-Thinkbox-Frost_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Krakatoa_64.png
│ │ ├── Arch_AWS-Thinkbox-Krakatoa_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Sequoia_64.png
│ │ ├── Arch_AWS-Thinkbox-Sequoia_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-Stoke_64.png
│ │ ├── Arch_AWS-Thinkbox-Stoke_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Thinkbox-XMesh_64.png
│ │ ├── Arch_AWS-Thinkbox-XMesh_64.svg
│ │ └── [email protected]
│ ├── migration-modernization
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Application-Discovery-Service_16.png
│ │ │ ├── Arch_AWS-Application-Discovery-Service_16.svg
│ │ │ ├── Arch_AWS-Application-Migration-Service_16.png
│ │ │ ├── Arch_AWS-Application-Migration-Service_16.svg
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_16.png
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_16.svg
│ │ │ ├── Arch_AWS-DataSync_16.png
│ │ │ ├── Arch_AWS-DataSync_16.svg
│ │ │ ├── Arch_AWS-Mainframe-Modernization_16.png
│ │ │ ├── Arch_AWS-Mainframe-Modernization_16.svg
│ │ │ ├── Arch_AWS-Migration-Evaluator_16.png
│ │ │ ├── Arch_AWS-Migration-Evaluator_16.svg
│ │ │ ├── Arch_AWS-Migration-Hub_16.png
│ │ │ ├── Arch_AWS-Migration-Hub_16.svg
│ │ │ ├── Arch_AWS-Transfer-Family_16.png
│ │ │ ├── Arch_AWS-Transfer-Family_16.svg
│ │ │ ├── Arch_AWS-Transform_16.png
│ │ │ └── Arch_AWS-Transform_16.svg
│ │ ├── 32
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Application-Discovery-Service_32.png
│ │ │ ├── Arch_AWS-Application-Discovery-Service_32.svg
│ │ │ ├── Arch_AWS-Application-Migration-Service_32.png
│ │ │ ├── Arch_AWS-Application-Migration-Service_32.svg
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_32.png
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_32.svg
│ │ │ ├── Arch_AWS-DataSync_32.png
│ │ │ ├── Arch_AWS-DataSync_32.svg
│ │ │ ├── Arch_AWS-Mainframe-Modernization_32.png
│ │ │ ├── Arch_AWS-Mainframe-Modernization_32.svg
│ │ │ ├── Arch_AWS-Migration-Evaluator_32.png
│ │ │ ├── Arch_AWS-Migration-Evaluator_32.svg
│ │ │ ├── Arch_AWS-Migration-Hub_32.png
│ │ │ ├── Arch_AWS-Migration-Hub_32.svg
│ │ │ ├── Arch_AWS-Transfer-Family_32.png
│ │ │ ├── Arch_AWS-Transfer-Family_32.svg
│ │ │ ├── Arch_AWS-Transform_32.png
│ │ │ └── Arch_AWS-Transform_32.svg
│ │ ├── 48
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_AWS-Application-Discovery-Service_48.png
│ │ │ ├── Arch_AWS-Application-Discovery-Service_48.svg
│ │ │ ├── Arch_AWS-Application-Migration-Service_48.png
│ │ │ ├── Arch_AWS-Application-Migration-Service_48.svg
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_48.png
│ │ │ ├── Arch_AWS-Data-Transfer-Terminal_48.svg
│ │ │ ├── Arch_AWS-DataSync_48.png
│ │ │ ├── Arch_AWS-DataSync_48.svg
│ │ │ ├── Arch_AWS-Mainframe-Modernization_48.png
│ │ │ ├── Arch_AWS-Mainframe-Modernization_48.svg
│ │ │ ├── Arch_AWS-Migration-Evaluator_48.png
│ │ │ ├── Arch_AWS-Migration-Evaluator_48.svg
│ │ │ ├── Arch_AWS-Migration-Hub_48.png
│ │ │ ├── Arch_AWS-Migration-Hub_48.svg
│ │ │ ├── Arch_AWS-Transfer-Family_48.png
│ │ │ ├── Arch_AWS-Transfer-Family_48.svg
│ │ │ ├── Arch_AWS-Transform_48.png
│ │ │ └── Arch_AWS-Transform_48.svg
│ │ └── 64
│ │ ├── .DS_Store
│ │ ├── Arch_AWS-Application-Discovery-Service_64.png
│ │ ├── Arch_AWS-Application-Discovery-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Application-Migration-Service_64.png
│ │ ├── Arch_AWS-Application-Migration-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Data-Transfer-Terminal_64.png
│ │ ├── Arch_AWS-Data-Transfer-Terminal_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-DataSync_64.png
│ │ ├── Arch_AWS-DataSync_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Mainframe-Modernization_64.png
│ │ ├── Arch_AWS-Mainframe-Modernization_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Migration-Evaluator_64.png
│ │ ├── Arch_AWS-Migration-Evaluator_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Migration-Hub_64.png
│ │ ├── Arch_AWS-Migration-Hub_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Transfer-Family_64.png
│ │ ├── Arch_AWS-Transfer-Family_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Transform_64.png
│ │ ├── Arch_AWS-Transform_64.svg
│ │ └── [email protected]
│ ├── networking-content-delivery
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── .DS_Store
│ │ │ ├── Arch_Amazon-API-Gateway_16.png
│ │ │ ├── Arch_Amazon-API-Gateway_16.svg
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_16.png
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_16.svg
│ │ │ ├── Arch_Amazon-CloudFront_16.png
│ │ │ ├── Arch_Amazon-CloudFront_16.svg
│ │ │ ├── Arch_Amazon-Route-53_16.png
│ │ │ ├── Arch_Amazon-Route-53_16.svg
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_16.png
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_16.svg
│ │ │ ├── Arch_Amazon-VPC-Lattice_16.png
│ │ │ ├── Arch_Amazon-VPC-Lattice_16.svg
│ │ │ ├── Arch_AWS-App-Mesh_16.png
│ │ │ ├── Arch_AWS-App-Mesh_16.svg
│ │ │ ├── Arch_AWS-Client-VPN_16.png
│ │ │ ├── Arch_AWS-Client-VPN_16.svg
│ │ │ ├── Arch_AWS-Cloud-Map_16.png
│ │ │ ├── Arch_AWS-Cloud-Map_16.svg
│ │ │ ├── Arch_AWS-Cloud-WAN_16.png
│ │ │ ├── Arch_AWS-Cloud-WAN_16.svg
│ │ │ ├── Arch_AWS-Direct-Connect_16.png
│ │ │ ├── Arch_AWS-Direct-Connect_16.svg
│ │ │ ├── Arch_AWS-Global-Accelerator_16.png
│ │ │ ├── Arch_AWS-Global-Accelerator_16.svg
│ │ │ ├── Arch_AWS-Private-5G_16.png
│ │ │ ├── Arch_AWS-Private-5G_16.svg
│ │ │ ├── Arch_AWS-PrivateLink_16.png
│ │ │ ├── Arch_AWS-PrivateLink_16.svg
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_16.png
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_16.svg
│ │ │ ├── Arch_AWS-Transit-Gateway_16.png
│ │ │ ├── Arch_AWS-Transit-Gateway_16.svg
│ │ │ ├── Arch_AWS-Verified-Access_16.png
│ │ │ ├── Arch_AWS-Verified-Access_16.svg
│ │ │ ├── Arch_Elastic-Load-Balancing_16.png
│ │ │ └── Arch_Elastic-Load-Balancing_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-API-Gateway_32.png
│ │ │ ├── Arch_Amazon-API-Gateway_32.svg
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_32.png
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_32.svg
│ │ │ ├── Arch_Amazon-CloudFront_32.png
│ │ │ ├── Arch_Amazon-CloudFront_32.svg
│ │ │ ├── Arch_Amazon-Route-53_32.png
│ │ │ ├── Arch_Amazon-Route-53_32.svg
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_32.png
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_32.svg
│ │ │ ├── Arch_Amazon-VPC-Lattice_32.png
│ │ │ ├── Arch_Amazon-VPC-Lattice_32.svg
│ │ │ ├── Arch_AWS-App-Mesh_32.png
│ │ │ ├── Arch_AWS-App-Mesh_32.svg
│ │ │ ├── Arch_AWS-Client-VPN_32.png
│ │ │ ├── Arch_AWS-Client-VPN_32.svg
│ │ │ ├── Arch_AWS-Cloud-Map_32.png
│ │ │ ├── Arch_AWS-Cloud-Map_32.svg
│ │ │ ├── Arch_AWS-Cloud-WAN_32.png
│ │ │ ├── Arch_AWS-Cloud-WAN_32.svg
│ │ │ ├── Arch_AWS-Direct-Connect_32.png
│ │ │ ├── Arch_AWS-Direct-Connect_32.svg
│ │ │ ├── Arch_AWS-Global-Accelerator_32.png
│ │ │ ├── Arch_AWS-Global-Accelerator_32.svg
│ │ │ ├── Arch_AWS-Private-5G_32.png
│ │ │ ├── Arch_AWS-Private-5G_32.svg
│ │ │ ├── Arch_AWS-PrivateLink_32.png
│ │ │ ├── Arch_AWS-PrivateLink_32.svg
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_32.png
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_32.svg
│ │ │ ├── Arch_AWS-Transit-Gateway_32.png
│ │ │ ├── Arch_AWS-Transit-Gateway_32.svg
│ │ │ ├── Arch_AWS-Verified-Access_32.png
│ │ │ ├── Arch_AWS-Verified-Access_32.svg
│ │ │ ├── Arch_Elastic-Load-Balancing_32.png
│ │ │ └── Arch_Elastic-Load-Balancing_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-API-Gateway_48.png
│ │ │ ├── Arch_Amazon-API-Gateway_48.svg
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_48.png
│ │ │ ├── Arch_Amazon-Application-Recovery-Controller_48.svg
│ │ │ ├── Arch_Amazon-CloudFront_48.png
│ │ │ ├── Arch_Amazon-CloudFront_48.svg
│ │ │ ├── Arch_Amazon-Route-53_48.png
│ │ │ ├── Arch_Amazon-Route-53_48.svg
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_48.png
│ │ │ ├── Arch_Amazon-Virtual-Private-Cloud_48.svg
│ │ │ ├── Arch_Amazon-VPC-Lattice_48.png
│ │ │ ├── Arch_Amazon-VPC-Lattice_48.svg
│ │ │ ├── Arch_AWS-App-Mesh_48.png
│ │ │ ├── Arch_AWS-App-Mesh_48.svg
│ │ │ ├── Arch_AWS-Client-VPN_48.png
│ │ │ ├── Arch_AWS-Client-VPN_48.svg
│ │ │ ├── Arch_AWS-Cloud-Map_48.png
│ │ │ ├── Arch_AWS-Cloud-Map_48.svg
│ │ │ ├── Arch_AWS-Cloud-WAN_48.png
│ │ │ ├── Arch_AWS-Cloud-WAN_48.svg
│ │ │ ├── Arch_AWS-Direct-Connect_48.png
│ │ │ ├── Arch_AWS-Direct-Connect_48.svg
│ │ │ ├── Arch_AWS-Global-Accelerator_48.png
│ │ │ ├── Arch_AWS-Global-Accelerator_48.svg
│ │ │ ├── Arch_AWS-Private-5G_48.png
│ │ │ ├── Arch_AWS-Private-5G_48.svg
│ │ │ ├── Arch_AWS-PrivateLink_48.png
│ │ │ ├── Arch_AWS-PrivateLink_48.svg
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_48.png
│ │ │ ├── Arch_AWS-Site-to-Site-VPN_48.svg
│ │ │ ├── Arch_AWS-Transit-Gateway_48.png
│ │ │ ├── Arch_AWS-Transit-Gateway_48.svg
│ │ │ ├── Arch_AWS-Verified-Access_48.png
│ │ │ ├── Arch_AWS-Verified-Access_48.svg
│ │ │ ├── Arch_Elastic-Load-Balancing_48.png
│ │ │ └── Arch_Elastic-Load-Balancing_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-API-Gateway_64.png
│ │ ├── Arch_Amazon-API-Gateway_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Application-Recovery-Controller_64.png
│ │ ├── Arch_Amazon-Application-Recovery-Controller_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-CloudFront_64.png
│ │ ├── Arch_Amazon-CloudFront_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Route-53_64.png
│ │ ├── Arch_Amazon-Route-53_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Virtual-Private-Cloud_64.png
│ │ ├── Arch_Amazon-Virtual-Private-Cloud_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-VPC-Lattice_64.png
│ │ ├── Arch_Amazon-VPC-Lattice_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-App-Mesh_64.png
│ │ ├── Arch_AWS-App-Mesh_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Client-VPN_64.png
│ │ ├── Arch_AWS-Client-VPN_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-Map_64.png
│ │ ├── Arch_AWS-Cloud-Map_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Cloud-WAN_64.png
│ │ ├── Arch_AWS-Cloud-WAN_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Direct-Connect_64.png
│ │ ├── Arch_AWS-Direct-Connect_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Global-Accelerator_64.png
│ │ ├── Arch_AWS-Global-Accelerator_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Private-5G_64.png
│ │ ├── Arch_AWS-Private-5G_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-PrivateLink_64.png
│ │ ├── Arch_AWS-PrivateLink_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Site-to-Site-VPN_64.png
│ │ ├── Arch_AWS-Site-to-Site-VPN_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Transit-Gateway_64.png
│ │ ├── Arch_AWS-Transit-Gateway_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Verified-Access_64.png
│ │ ├── Arch_AWS-Verified-Access_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Elastic-Load-Balancing_64.png
│ │ ├── Arch_Elastic-Load-Balancing_64.svg
│ │ └── [email protected]
│ ├── quantum-technologies
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Braket_16.png
│ │ │ └── Arch_Amazon-Braket_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Braket_32.png
│ │ │ └── Arch_Amazon-Braket_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Braket_48.png
│ │ │ └── Arch_Amazon-Braket_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Braket_64.png
│ │ ├── Arch_Amazon-Braket_64.svg
│ │ └── [email protected]
│ ├── satellite
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_AWS-Ground-Station_16.png
│ │ │ └── Arch_AWS-Ground-Station_16.svg
│ │ ├── 32
│ │ │ ├── Arch_AWS-Ground-Station_32.png
│ │ │ └── Arch_AWS-Ground-Station_32.svg
│ │ ├── 48
│ │ │ ├── Arch_AWS-Ground-Station_48.png
│ │ │ └── Arch_AWS-Ground-Station_48.svg
│ │ └── 64
│ │ ├── Arch_AWS-Ground-Station_64.png
│ │ ├── Arch_AWS-Ground-Station_64.svg
│ │ └── [email protected]
│ ├── security-identity-compliance
│ │ ├── .DS_Store
│ │ ├── 16
│ │ │ ├── Arch_Amazon-Cloud-Directory_16.png
│ │ │ ├── Arch_Amazon-Cloud-Directory_16.svg
│ │ │ ├── Arch_Amazon-Cognito_16.png
│ │ │ ├── Arch_Amazon-Cognito_16.svg
│ │ │ ├── Arch_Amazon-Detective_16.png
│ │ │ ├── Arch_Amazon-Detective_16.svg
│ │ │ ├── Arch_Amazon-GuardDuty_16.png
│ │ │ ├── Arch_Amazon-GuardDuty_16.svg
│ │ │ ├── Arch_Amazon-Inspector_16.png
│ │ │ ├── Arch_Amazon-Inspector_16.svg
│ │ │ ├── Arch_Amazon-Macie_16.png
│ │ │ ├── Arch_Amazon-Macie_16.svg
│ │ │ ├── Arch_Amazon-Security-Lake_16.png
│ │ │ ├── Arch_Amazon-Security-Lake_16.svg
│ │ │ ├── Arch_Amazon-Verified-Permissions_16.png
│ │ │ ├── Arch_Amazon-Verified-Permissions_16.svg
│ │ │ ├── Arch_AWS-Artifact_16.png
│ │ │ ├── Arch_AWS-Artifact_16.svg
│ │ │ ├── Arch_AWS-Audit-Manager_16.png
│ │ │ ├── Arch_AWS-Audit-Manager_16.svg
│ │ │ ├── Arch_AWS-Certificate-Manager_16.png
│ │ │ ├── Arch_AWS-Certificate-Manager_16.svg
│ │ │ ├── Arch_AWS-CloudHSM_16.png
│ │ │ ├── Arch_AWS-CloudHSM_16.svg
│ │ │ ├── Arch_AWS-Directory-Service_16.png
│ │ │ ├── Arch_AWS-Directory-Service_16.svg
│ │ │ ├── Arch_AWS-Firewall-Manager_16.png
│ │ │ ├── Arch_AWS-Firewall-Manager_16.svg
│ │ │ ├── Arch_AWS-IAM-Identity-Center_16.png
│ │ │ ├── Arch_AWS-IAM-Identity-Center_16.svg
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_16.png
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_16.svg
│ │ │ ├── Arch_AWS-Key-Management-Service_16.png
│ │ │ ├── Arch_AWS-Key-Management-Service_16.svg
│ │ │ ├── Arch_AWS-Network-Firewall_16.png
│ │ │ ├── Arch_AWS-Network-Firewall_16.svg
│ │ │ ├── Arch_AWS-Payment-Cryptography_16.png
│ │ │ ├── Arch_AWS-Payment-Cryptography_16.svg
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_16.png
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_16.svg
│ │ │ ├── Arch_AWS-Resource-Access-Manager_16.png
│ │ │ ├── Arch_AWS-Resource-Access-Manager_16.svg
│ │ │ ├── Arch_AWS-Secrets-Manager_16.png
│ │ │ ├── Arch_AWS-Secrets-Manager_16.svg
│ │ │ ├── Arch_AWS-Security-Hub_16.png
│ │ │ ├── Arch_AWS-Security-Hub_16.svg
│ │ │ ├── Arch_AWS-Security-Incident-Response_16.png
│ │ │ ├── Arch_AWS-Security-Incident-Response_16.svg
│ │ │ ├── Arch_AWS-Shield_16.png
│ │ │ ├── Arch_AWS-Shield_16.svg
│ │ │ ├── Arch_AWS-Signer_16.png
│ │ │ ├── Arch_AWS-Signer_16.svg
│ │ │ ├── Arch_AWS-WAF_16.png
│ │ │ └── Arch_AWS-WAF_16.svg
│ │ ├── 32
│ │ │ ├── Arch_Amazon-Cloud-Directory_32.png
│ │ │ ├── Arch_Amazon-Cloud-Directory_32.svg
│ │ │ ├── Arch_Amazon-Cognito_32.png
│ │ │ ├── Arch_Amazon-Cognito_32.svg
│ │ │ ├── Arch_Amazon-Detective_32.png
│ │ │ ├── Arch_Amazon-Detective_32.svg
│ │ │ ├── Arch_Amazon-GuardDuty_32.png
│ │ │ ├── Arch_Amazon-GuardDuty_32.svg
│ │ │ ├── Arch_Amazon-Inspector_32.png
│ │ │ ├── Arch_Amazon-Inspector_32.svg
│ │ │ ├── Arch_Amazon-Macie_32.png
│ │ │ ├── Arch_Amazon-Macie_32.svg
│ │ │ ├── Arch_Amazon-Security-Lake_32.png
│ │ │ ├── Arch_Amazon-Security-Lake_32.svg
│ │ │ ├── Arch_Amazon-Verified-Permissions_32.png
│ │ │ ├── Arch_Amazon-Verified-Permissions_32.svg
│ │ │ ├── Arch_AWS-Artifact_32.png
│ │ │ ├── Arch_AWS-Artifact_32.svg
│ │ │ ├── Arch_AWS-Audit-Manager_32.png
│ │ │ ├── Arch_AWS-Audit-Manager_32.svg
│ │ │ ├── Arch_AWS-Certificate-Manager_32.png
│ │ │ ├── Arch_AWS-Certificate-Manager_32.svg
│ │ │ ├── Arch_AWS-CloudHSM_32.png
│ │ │ ├── Arch_AWS-CloudHSM_32.svg
│ │ │ ├── Arch_AWS-Directory-Service_32.png
│ │ │ ├── Arch_AWS-Directory-Service_32.svg
│ │ │ ├── Arch_AWS-Firewall-Manager_32.png
│ │ │ ├── Arch_AWS-Firewall-Manager_32.svg
│ │ │ ├── Arch_AWS-IAM-Identity-Center_32.png
│ │ │ ├── Arch_AWS-IAM-Identity-Center_32.svg
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_32.png
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_32.svg
│ │ │ ├── Arch_AWS-Key-Management-Service_32.png
│ │ │ ├── Arch_AWS-Key-Management-Service_32.svg
│ │ │ ├── Arch_AWS-Network-Firewall_32.png
│ │ │ ├── Arch_AWS-Network-Firewall_32.svg
│ │ │ ├── Arch_AWS-Payment-Cryptography_32.png
│ │ │ ├── Arch_AWS-Payment-Cryptography_32.svg
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_32.png
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_32.svg
│ │ │ ├── Arch_AWS-Resource-Access-Manager_32.png
│ │ │ ├── Arch_AWS-Resource-Access-Manager_32.svg
│ │ │ ├── Arch_AWS-Secrets-Manager_32.png
│ │ │ ├── Arch_AWS-Secrets-Manager_32.svg
│ │ │ ├── Arch_AWS-Security-Hub_32.png
│ │ │ ├── Arch_AWS-Security-Hub_32.svg
│ │ │ ├── Arch_AWS-Security-Incident-Response_32.png
│ │ │ ├── Arch_AWS-Security-Incident-Response_32.svg
│ │ │ ├── Arch_AWS-Shield_32.png
│ │ │ ├── Arch_AWS-Shield_32.svg
│ │ │ ├── Arch_AWS-Signer_32.png
│ │ │ ├── Arch_AWS-Signer_32.svg
│ │ │ ├── Arch_AWS-WAF_32.png
│ │ │ └── Arch_AWS-WAF_32.svg
│ │ ├── 48
│ │ │ ├── Arch_Amazon-Cloud-Directory_48.png
│ │ │ ├── Arch_Amazon-Cloud-Directory_48.svg
│ │ │ ├── Arch_Amazon-Cognito_48.png
│ │ │ ├── Arch_Amazon-Cognito_48.svg
│ │ │ ├── Arch_Amazon-Detective_48.png
│ │ │ ├── Arch_Amazon-Detective_48.svg
│ │ │ ├── Arch_Amazon-GuardDuty_48.png
│ │ │ ├── Arch_Amazon-GuardDuty_48.svg
│ │ │ ├── Arch_Amazon-Inspector_48.png
│ │ │ ├── Arch_Amazon-Inspector_48.svg
│ │ │ ├── Arch_Amazon-Macie_48.png
│ │ │ ├── Arch_Amazon-Macie_48.svg
│ │ │ ├── Arch_Amazon-Security-Lake_48.png
│ │ │ ├── Arch_Amazon-Security-Lake_48.svg
│ │ │ ├── Arch_Amazon-Verified-Permissions_48.png
│ │ │ ├── Arch_Amazon-Verified-Permissions_48.svg
│ │ │ ├── Arch_AWS-Artifact_48.png
│ │ │ ├── Arch_AWS-Artifact_48.svg
│ │ │ ├── Arch_AWS-Audit-Manager_48.png
│ │ │ ├── Arch_AWS-Audit-Manager_48.svg
│ │ │ ├── Arch_AWS-Certificate-Manager_48.png
│ │ │ ├── Arch_AWS-Certificate-Manager_48.svg
│ │ │ ├── Arch_AWS-CloudHSM_48.png
│ │ │ ├── Arch_AWS-CloudHSM_48.svg
│ │ │ ├── Arch_AWS-Directory-Service_48.png
│ │ │ ├── Arch_AWS-Directory-Service_48.svg
│ │ │ ├── Arch_AWS-Firewall-Manager_48.png
│ │ │ ├── Arch_AWS-Firewall-Manager_48.svg
│ │ │ ├── Arch_AWS-IAM-Identity-Center_48.png
│ │ │ ├── Arch_AWS-IAM-Identity-Center_48.svg
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_48.png
│ │ │ ├── Arch_AWS-Identity-and-Access-Management_48.svg
│ │ │ ├── Arch_AWS-Key-Management-Service_48.png
│ │ │ ├── Arch_AWS-Key-Management-Service_48.svg
│ │ │ ├── Arch_AWS-Network-Firewall_48.png
│ │ │ ├── Arch_AWS-Network-Firewall_48.svg
│ │ │ ├── Arch_AWS-Payment-Cryptography_48.png
│ │ │ ├── Arch_AWS-Payment-Cryptography_48.svg
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_48.png
│ │ │ ├── Arch_AWS-Private-Certificate-Authority_48.svg
│ │ │ ├── Arch_AWS-Resource-Access-Manager_48.png
│ │ │ ├── Arch_AWS-Resource-Access-Manager_48.svg
│ │ │ ├── Arch_AWS-Secrets-Manager_48.png
│ │ │ ├── Arch_AWS-Secrets-Manager_48.svg
│ │ │ ├── Arch_AWS-Security-Hub_48.png
│ │ │ ├── Arch_AWS-Security-Hub_48.svg
│ │ │ ├── Arch_AWS-Security-Incident-Response_48.png
│ │ │ ├── Arch_AWS-Security-Incident-Response_48.svg
│ │ │ ├── Arch_AWS-Shield_48.png
│ │ │ ├── Arch_AWS-Shield_48.svg
│ │ │ ├── Arch_AWS-Signer_48.png
│ │ │ ├── Arch_AWS-Signer_48.svg
│ │ │ ├── Arch_AWS-WAF_48.png
│ │ │ └── Arch_AWS-WAF_48.svg
│ │ └── 64
│ │ ├── Arch_Amazon-Cloud-Directory_64.png
│ │ ├── Arch_Amazon-Cloud-Directory_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Cognito_64.png
│ │ ├── Arch_Amazon-Cognito_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Detective_64.png
│ │ ├── Arch_Amazon-Detective_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-GuardDuty_64.png
│ │ ├── Arch_Amazon-GuardDuty_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Inspector_64.png
│ │ ├── Arch_Amazon-Inspector_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Macie_64.png
│ │ ├── Arch_Amazon-Macie_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Security-Lake_64.png
│ │ ├── Arch_Amazon-Security-Lake_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_Amazon-Verified-Permissions_64.png
│ │ ├── Arch_Amazon-Verified-Permissions_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Artifact_64.png
│ │ ├── Arch_AWS-Artifact_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Audit-Manager_64.png
│ │ ├── Arch_AWS-Audit-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Certificate-Manager_64.png
│ │ ├── Arch_AWS-Certificate-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-CloudHSM_64.png
│ │ ├── Arch_AWS-CloudHSM_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Directory-Service_64.png
│ │ ├── Arch_AWS-Directory-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Firewall-Manager_64.png
│ │ ├── Arch_AWS-Firewall-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-IAM-Identity-Center_64.png
│ │ ├── Arch_AWS-IAM-Identity-Center_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Identity-and-Access-Management_64.png
│ │ ├── Arch_AWS-Identity-and-Access-Management_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Key-Management-Service_64.png
│ │ ├── Arch_AWS-Key-Management-Service_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Network-Firewall_64.png
│ │ ├── Arch_AWS-Network-Firewall_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Payment-Cryptography_64.png
│ │ ├── Arch_AWS-Payment-Cryptography_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Private-Certificate-Authority_64.png
│ │ ├── Arch_AWS-Private-Certificate-Authority_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Resource-Access-Manager_64.png
│ │ ├── Arch_AWS-Resource-Access-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Secrets-Manager_64.png
│ │ ├── Arch_AWS-Secrets-Manager_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Security-Hub_64.png
│ │ ├── Arch_AWS-Security-Hub_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Security-Incident-Response_64.png
│ │ ├── Arch_AWS-Security-Incident-Response_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Shield_64.png
│ │ ├── Arch_AWS-Shield_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-Signer_64.png
│ │ ├── Arch_AWS-Signer_64.svg
│ │ ├── [email protected]
│ │ ├── Arch_AWS-WAF_64.png
│ │ ├── Arch_AWS-WAF_64.svg
│ │ └── [email protected]
│ └── storage
│ ├── .DS_Store
│ ├── 16
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-EFS_16.png
│ │ ├── Arch_Amazon-EFS_16.svg
│ │ ├── Arch_Amazon-Elastic-Block-Store_16.png
│ │ ├── Arch_Amazon-Elastic-Block-Store_16.svg
│ │ ├── Arch_Amazon-File-Cache_16.png
│ │ ├── Arch_Amazon-File-Cache_16.svg
│ │ ├── Arch_Amazon-FSx_16.png
│ │ ├── Arch_Amazon-FSx_16.svg
│ │ ├── Arch_Amazon-FSx-for-Lustre_16.png
│ │ ├── Arch_Amazon-FSx-for-Lustre_16.svg
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_16.png
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_16.svg
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_16.png
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_16.svg
│ │ ├── Arch_Amazon-FSx-for-WFS_16.png
│ │ ├── Arch_Amazon-FSx-for-WFS_16.svg
│ │ ├── Arch_Amazon-S3-on-Outposts_16.png
│ │ ├── Arch_Amazon-S3-on-Outposts_16.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service_16.png
│ │ ├── Arch_Amazon-Simple-Storage-Service_16.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_16.png
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_16.svg
│ │ ├── Arch_AWS-Backup_16.png
│ │ ├── Arch_AWS-Backup_16.svg
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_16.png
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_16.svg
│ │ ├── Arch_AWS-Snowball_16.png
│ │ ├── Arch_AWS-Snowball_16.svg
│ │ ├── Arch_AWS-Snowball-Edge_16.png
│ │ ├── Arch_AWS-Snowball-Edge_16.svg
│ │ ├── Arch_AWS-Storage-Gateway_16.png
│ │ └── Arch_AWS-Storage-Gateway_16.svg
│ ├── 32
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-EFS_32.png
│ │ ├── Arch_Amazon-EFS_32.svg
│ │ ├── Arch_Amazon-Elastic-Block-Store_32.png
│ │ ├── Arch_Amazon-Elastic-Block-Store_32.svg
│ │ ├── Arch_Amazon-File-Cache_32.png
│ │ ├── Arch_Amazon-File-Cache_32.svg
│ │ ├── Arch_Amazon-FSx_32.png
│ │ ├── Arch_Amazon-FSx_32.svg
│ │ ├── Arch_Amazon-FSx-for-Lustre_32.png
│ │ ├── Arch_Amazon-FSx-for-Lustre_32.svg
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_32.png
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_32.svg
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_32.png
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_32.svg
│ │ ├── Arch_Amazon-FSx-for-WFS_32.png
│ │ ├── Arch_Amazon-FSx-for-WFS_32.svg
│ │ ├── Arch_Amazon-S3-on-Outposts_32.png
│ │ ├── Arch_Amazon-S3-on-Outposts_32.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service_32.png
│ │ ├── Arch_Amazon-Simple-Storage-Service_32.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_32.png
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_32.svg
│ │ ├── Arch_AWS-Backup_32.png
│ │ ├── Arch_AWS-Backup_32.svg
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_32.png
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_32.svg
│ │ ├── Arch_AWS-Snowball_32.png
│ │ ├── Arch_AWS-Snowball_32.svg
│ │ ├── Arch_AWS-Snowball-Edge_32.png
│ │ ├── Arch_AWS-Snowball-Edge_32.svg
│ │ ├── Arch_AWS-Storage-Gateway_32.png
│ │ └── Arch_AWS-Storage-Gateway_32.svg
│ ├── 48
│ │ ├── .DS_Store
│ │ ├── Arch_Amazon-EFS_48.png
│ │ ├── Arch_Amazon-EFS_48.svg
│ │ ├── Arch_Amazon-Elastic-Block-Store_48.png
│ │ ├── Arch_Amazon-Elastic-Block-Store_48.svg
│ │ ├── Arch_Amazon-File-Cache_48.png
│ │ ├── Arch_Amazon-File-Cache_48.svg
│ │ ├── Arch_Amazon-FSx_48.png
│ │ ├── Arch_Amazon-FSx_48.svg
│ │ ├── Arch_Amazon-FSx-for-Lustre_48.png
│ │ ├── Arch_Amazon-FSx-for-Lustre_48.svg
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_48.png
│ │ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_48.svg
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_48.png
│ │ ├── Arch_Amazon-FSx-for-OpenZFS_48.svg
│ │ ├── Arch_Amazon-FSx-for-WFS_48.png
│ │ ├── Arch_Amazon-FSx-for-WFS_48.svg
│ │ ├── Arch_Amazon-S3-on-Outposts_48.png
│ │ ├── Arch_Amazon-S3-on-Outposts_48.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service_48.png
│ │ ├── Arch_Amazon-Simple-Storage-Service_48.svg
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_48.png
│ │ ├── Arch_Amazon-Simple-Storage-Service-Glacier_48.svg
│ │ ├── Arch_AWS-Backup_48.png
│ │ ├── Arch_AWS-Backup_48.svg
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_48.png
│ │ ├── Arch_AWS-Elastic-Disaster-Recovery_48.svg
│ │ ├── Arch_AWS-Snowball_48.png
│ │ ├── Arch_AWS-Snowball_48.svg
│ │ ├── Arch_AWS-Snowball-Edge_48.png
│ │ ├── Arch_AWS-Snowball-Edge_48.svg
│ │ ├── Arch_AWS-Storage-Gateway_48.png
│ │ └── Arch_AWS-Storage-Gateway_48.svg
│ └── 64
│ ├── .DS_Store
│ ├── Arch_Amazon-EFS_64.png
│ ├── Arch_Amazon-EFS_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-Elastic-Block-Store_64.png
│ ├── Arch_Amazon-Elastic-Block-Store_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-File-Cache_64.png
│ ├── Arch_Amazon-File-Cache_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx_64.png
│ ├── Arch_Amazon-FSx_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-Lustre_64.png
│ ├── Arch_Amazon-FSx-for-Lustre_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_64.png
│ ├── Arch_Amazon-FSx-for-NetApp-ONTAP_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-OpenZFS_64.png
│ ├── Arch_Amazon-FSx-for-OpenZFS_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-FSx-for-WFS_64.png
│ ├── Arch_Amazon-FSx-for-WFS_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-S3-on-Outposts_64.png
│ ├── Arch_Amazon-S3-on-Outposts_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-Simple-Storage-Service_64.png
│ ├── Arch_Amazon-Simple-Storage-Service_64.svg
│ ├── [email protected]
│ ├── Arch_Amazon-Simple-Storage-Service-Glacier_64.png
│ ├── Arch_Amazon-Simple-Storage-Service-Glacier_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Backup_64.png
│ ├── Arch_AWS-Backup_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Elastic-Disaster-Recovery_64.png
│ ├── Arch_AWS-Elastic-Disaster-Recovery_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Snowball_64.png
│ ├── Arch_AWS-Snowball_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Snowball-Edge_64.png
│ ├── Arch_AWS-Snowball-Edge_64.svg
│ ├── [email protected]
│ ├── Arch_AWS-Storage-Gateway_64.png
│ ├── Arch_AWS-Storage-Gateway_64.svg
│ └── [email protected]
├── index.html
├── manifest.json
├── mocks
│ ├── mock-discovery-live.json
│ └── mock-generate-graph.json
├── robots.txt
└── static
├── css
│ ├── main.f8f47ec8.css
│ └── main.f8f47ec8.css.map
└── js
├── 1297.c349ec3c.chunk.js
├── 14.7ba48ec4.chunk.js
├── 14.7ba48ec4.chunk.js.LICENSE.txt
├── 14.7ba48ec4.chunk.js.map
├── 1409.d2c5ac18.chunk.js
├── 1457.10b2696f.chunk.js
├── 1595.2e8c74e3.chunk.js
├── 1595.2e8c74e3.chunk.js.LICENSE.txt
├── 1595.2e8c74e3.chunk.js.map
├── 1707.279d4917.chunk.js
├── 1707.279d4917.chunk.js.map
├── 2019.3e4e6398.chunk.js
├── 2019.3e4e6398.chunk.js.map
├── 2038.86d3ba27.chunk.js
├── 2038.86d3ba27.chunk.js.map
├── 2374.220d0c1c.chunk.js
├── 2374.220d0c1c.chunk.js.LICENSE.txt
├── 2374.220d0c1c.chunk.js.map
├── 2491.6dc3b41c.chunk.js
├── 2491.6dc3b41c.chunk.js.map
├── 3025.e856e271.chunk.js
├── 3025.e856e271.chunk.js.LICENSE.txt
├── 3025.e856e271.chunk.js.map
├── 3119.2c9023ad.chunk.js
├── 3119.2c9023ad.chunk.js.LICENSE.txt
├── 3119.2c9023ad.chunk.js.map
├── 3290.6c752b7b.chunk.js
├── 3290.6c752b7b.chunk.js.map
├── 3345.719283e7.chunk.js
├── 3345.719283e7.chunk.js.map
├── 349.2456c1b6.chunk.js
├── 349.2456c1b6.chunk.js.map
├── 3641.87d0bf7c.chunk.js
├── 3641.87d0bf7c.chunk.js.map
├── 3705.1bb92025.chunk.js
├── 3705.1bb92025.chunk.js.map
├── 3750.c184e3e3.chunk.js
├── 3750.c184e3e3.chunk.js.map
├── 3817.79a57e5e.chunk.js
├── 3817.79a57e5e.chunk.js.map
├── 4114.eea3c770.chunk.js
├── 4114.eea3c770.chunk.js.map
├── 4135.b88aaf7b.chunk.js
├── 4147.5f8e8649.chunk.js
├── 4191.3ed02494.chunk.js
├── 4191.3ed02494.chunk.js.map
├── 4487.fec1d877.chunk.js
├── 4570.ce64aedb.chunk.js
├── 4570.ce64aedb.chunk.js.map
├── 490.a05b6059.chunk.js
├── 490.a05b6059.chunk.js.map
├── 5009.1a2aa685.chunk.js
├── 5009.1a2aa685.chunk.js.LICENSE.txt
├── 5009.1a2aa685.chunk.js.map
├── 5502.14766ceb.chunk.js
├── 5502.14766ceb.chunk.js.map
├── 62.b40b6fbd.chunk.js
├── 62.b40b6fbd.chunk.js.map
├── 6453.8c3fba0e.chunk.js
├── 6453.8c3fba0e.chunk.js.map
├── 6455.8e6b5278.chunk.js
├── 6455.8e6b5278.chunk.js.map
├── 646.6aac5035.chunk.js
├── 646.6aac5035.chunk.js.LICENSE.txt
├── 646.6aac5035.chunk.js.map
├── 6516.3948f7b4.chunk.js
├── 6516.3948f7b4.chunk.js.map
├── 6725.6ad72d9d.chunk.js
├── 6823.e10e9817.chunk.js
├── 6823.e10e9817.chunk.js.map
├── 6865.afd592a9.chunk.js
├── 6865.afd592a9.chunk.js.map
├── 6977.4218876a.chunk.js
├── 6977.4218876a.chunk.js.LICENSE.txt
├── 6977.4218876a.chunk.js.map
├── 7069.6c60b97c.chunk.js
├── 7069.6c60b97c.chunk.js.map
├── 7513.37f12f0e.chunk.js
├── 7513.37f12f0e.chunk.js.map
├── 7550.0cfdabcf.chunk.js
├── 7550.0cfdabcf.chunk.js.map
├── 7841.37a92b31.chunk.js
├── 7841.37a92b31.chunk.js.map
├── 7854.ed7e04cc.chunk.js
├── 7854.ed7e04cc.chunk.js.map
├── 8151.87df400e.chunk.js
├── 8151.87df400e.chunk.js.map
├── 8195.55a334cf.chunk.js
├── 8195.55a334cf.chunk.js.map
├── 8218.b7de3259.chunk.js
├── 8218.b7de3259.chunk.js.map
├── 8234.f2f9a7db.chunk.js
├── 8234.f2f9a7db.chunk.js.map
├── 8332.9aa74d00.chunk.js
├── 8332.9aa74d00.chunk.js.map
├── 8449.676bcc94.chunk.js
├── 8449.676bcc94.chunk.js.map
├── 8660.1c56263e.chunk.js
├── 8660.1c56263e.chunk.js.map
├── 9413.aea20916.chunk.js
├── 9413.aea20916.chunk.js.map
├── 9448.cd4e8095.chunk.js
├── 9448.cd4e8095.chunk.js.map
├── 9459.753274fe.chunk.js
├── 9459.753274fe.chunk.js.map
├── 9573.5ba95804.chunk.js
├── 9573.5ba95804.chunk.js.map
├── 9664.9e69f3bc.chunk.js
├── 9664.9e69f3bc.chunk.js.map
├── 9844.6366c533.chunk.js
├── 9844.6366c533.chunk.js.map
├── main.af8efd6b.js
├── main.af8efd6b.js.LICENSE.txt
└── main.af8efd6b.js.map
```
# Files
--------------------------------------------------------------------------------
/pkg/agent/mocks/mcp_server_mock.go:
--------------------------------------------------------------------------------
```go
package mocks
import (
"context"
"encoding/json"
"fmt"
"strings"
"sync"
"github.com/mark3labs/mcp-go/mcp"
"github.com/versus-control/ai-infrastructure-agent/internal/logging"
"github.com/versus-control/ai-infrastructure-agent/pkg/aws"
"github.com/versus-control/ai-infrastructure-agent/pkg/interfaces"
"github.com/versus-control/ai-infrastructure-agent/pkg/types"
)
// MockMCPServer implements a mock MCP server for testing
type MockMCPServer struct {
logger *logging.Logger
tools map[string]interfaces.MCPTool
resources map[string]*types.AWSResource
stateManager *MockStateManager
awsClient *MockAWSClient
mutex sync.RWMutex
// Response configuration
simulateErrors map[string]error
customResponses map[string]*mcp.CallToolResult
}
// NewMockMCPServer creates a new mock MCP server
func NewMockMCPServer(logger *logging.Logger) *MockMCPServer {
return &MockMCPServer{
logger: logger,
tools: make(map[string]interfaces.MCPTool),
resources: make(map[string]*types.AWSResource),
stateManager: NewMockStateManager(),
awsClient: nil, // Will be set via SetAWSClient
simulateErrors: make(map[string]error),
customResponses: make(map[string]*mcp.CallToolResult),
}
}
// NewMockMCPServerWithAWSClient creates a new mock MCP server with AWS client
func NewMockMCPServerWithAWSClient(logger *logging.Logger, awsClient *MockAWSClient) *MockMCPServer {
return &MockMCPServer{
logger: logger,
tools: make(map[string]interfaces.MCPTool),
resources: make(map[string]*types.AWSResource),
stateManager: NewMockStateManager(),
awsClient: awsClient,
simulateErrors: make(map[string]error),
customResponses: make(map[string]*mcp.CallToolResult),
}
}
// SetAWSClient sets the AWS client for the mock server
func (m *MockMCPServer) SetAWSClient(awsClient *MockAWSClient) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.awsClient = awsClient
}
// Execute implements the MCPTool interface for the mock server itself
func (m *MockMCPServer) Execute(ctx context.Context, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
// This method allows the MockMCPServer to be used as an MCPTool
// It delegates to CallTool with a default tool name if provided in arguments
if toolName, ok := arguments["tool_name"].(string); ok {
// Remove tool_name from arguments before calling the tool
toolArgs := make(map[string]interface{})
for k, v := range arguments {
if k != "tool_name" {
toolArgs[k] = v
}
}
return m.CallTool(ctx, toolName, toolArgs)
}
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "MockMCPServer Execute requires 'tool_name' parameter",
},
},
}, nil
}
// Name implements MCPTool interface
func (m *MockMCPServer) Name() string {
return "mock-mcp-server"
}
// Description implements MCPTool interface
func (m *MockMCPServer) Description() string {
return "Mock MCP server for testing"
}
// Category implements MCPTool interface
func (m *MockMCPServer) Category() string {
return "testing"
}
// GetInputSchema implements MCPTool interface
func (m *MockMCPServer) GetInputSchema() map[string]interface{} {
return map[string]interface{}{
"type": "object",
"properties": map[string]interface{}{
"tool_name": map[string]interface{}{
"type": "string",
"description": "Name of the tool to execute",
},
},
"required": []string{"tool_name"},
}
}
// GetOutputSchema implements MCPTool interface
func (m *MockMCPServer) GetOutputSchema() map[string]interface{} {
return map[string]interface{}{
"type": "object",
"description": "Tool execution result",
}
}
// GetExamples implements MCPTool interface
func (m *MockMCPServer) GetExamples() []interfaces.ToolExample {
return []interfaces.ToolExample{
{
Description: "Execute a mock tool",
Arguments: map[string]interface{}{
"tool_name": "create-vpc",
"name": "test-vpc",
"cidrBlock": "10.0.0.0/16",
},
Expected: "VPC creation result",
},
}
}
// ValidateArguments implements MCPTool interface
func (m *MockMCPServer) ValidateArguments(arguments map[string]interface{}) error {
if _, ok := arguments["tool_name"]; !ok {
return fmt.Errorf("tool_name is required")
}
return nil
}
// RegisterTool registers a tool with the mock server
func (m *MockMCPServer) RegisterTool(tool interfaces.MCPTool) error {
m.mutex.Lock()
defer m.mutex.Unlock()
m.tools[tool.Name()] = tool
m.logger.Info("Registered mock tool", "tool", tool.Name())
return nil
}
// CallTool simulates calling an MCP tool
func (m *MockMCPServer) CallTool(ctx context.Context, toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
m.mutex.RLock()
defer m.mutex.RUnlock()
// Check for simulated errors
if err, exists := m.simulateErrors[toolName]; exists {
return nil, err
}
// Check for custom responses
if response, exists := m.customResponses[toolName]; exists {
return response, nil
}
// Check if tool exists
tool, exists := m.tools[toolName]
if !exists {
// Generate default mock response for common tools
return m.generateMockToolResponse(toolName, arguments)
}
// Execute the actual tool with mocked dependencies
return tool.Execute(ctx, arguments)
}
// generateMockToolResponse generates default responses for common AWS tools
func (m *MockMCPServer) generateMockToolResponse(toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
// If AWS client is available, use AWS client versions for better integration
if m.awsClient != nil {
return m.generateMockToolResponseWithAWSClient(toolName, arguments)
}
// Fallback to static responses when no AWS client is available
return m.generateMockToolResponseFallback(toolName, arguments)
}
// generateMockToolResponseWithAWSClient uses AWS client for realistic mock responses
func (m *MockMCPServer) generateMockToolResponseWithAWSClient(toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
switch {
// VPC Tools
case toolName == "create-vpc":
return m.mockCreateVPCWithAWSClient(arguments)
case toolName == "list-vpcs":
return m.mockListVPCsWithAWSClient(arguments)
case toolName == "get-default-vpc":
return m.mockGetDefaultVPC(arguments)
// Subnet Tools
case toolName == "create-subnet":
return m.mockCreateSubnetWithAWSClient(arguments)
case toolName == "create-private-subnet":
return m.mockCreatePrivateSubnet(arguments)
case toolName == "create-public-subnet":
return m.mockCreatePublicSubnet(arguments)
case toolName == "list-subnets":
return m.mockListSubnets(arguments)
case toolName == "list-subnets-for-alb":
return m.mockSelectSubnetsForALB(arguments)
// Networking Infrastructure Tools
case toolName == "create-internet-gateway":
return m.mockCreateInternetGateway(arguments)
case toolName == "create-nat-gateway":
return m.mockCreateNATGateway(arguments)
case toolName == "create-public-route-table":
return m.mockCreatePublicRouteTable(arguments)
case toolName == "create-private-route-table":
return m.mockCreatePrivateRouteTable(arguments)
case toolName == "associate-route-table":
return m.mockAssociateRouteTable(arguments)
case toolName == "add-route":
return m.mockAddRoute(arguments)
// EC2 Tools
case toolName == "create-ec2-instance":
return m.mockCreateEC2InstanceWithAWSClient(arguments)
case toolName == "list-ec2-instances":
return m.mockListEC2Instances(arguments)
case toolName == "start-ec2-instance":
return m.mockStartEC2Instance(arguments)
case toolName == "stop-ec2-instance":
return m.mockStopEC2Instance(arguments)
case toolName == "terminate-ec2-instance":
return m.mockTerminateEC2Instance(arguments)
case toolName == "create-ami-from-instance":
return m.mockCreateAMIFromInstance(arguments)
case toolName == "list-amis":
return m.mockListAMIs(arguments)
case toolName == "get-latest-ami":
return m.mockGetLatestAMI(arguments)
case toolName == "get-latest-amazon-linux-ami":
return m.mockGetLatestAmazonLinuxAMI(arguments)
case toolName == "get-latest-ubuntu-ami":
return m.mockGetLatestUbuntuAMI(arguments)
// Load Balancer Tools
case toolName == "create-load-balancer":
return m.mockCreateLoadBalancer(arguments)
case toolName == "create-target-group":
return m.mockCreateTargetGroup(arguments)
case toolName == "create-listener":
return m.mockCreateListener(arguments)
case toolName == "list-load-balancers":
return m.mockListLoadBalancers(arguments)
case toolName == "list-target-groups":
return m.mockListTargetGroups(arguments)
case toolName == "register-targets":
return m.mockRegisterTargets(arguments)
case toolName == "deregister-targets":
return m.mockDeregisterTargets(arguments)
// RDS Tools
case toolName == "create-db-subnet-group":
return m.mockCreateDBSubnetGroup(arguments)
case toolName == "create-db-instance":
return m.mockCreateDBInstance(arguments)
case toolName == "start-db-instance":
return m.mockStartDBInstance(arguments)
case toolName == "stop-db-instance":
return m.mockStopDBInstance(arguments)
case toolName == "delete-db-instance":
return m.mockDeleteDBInstance(arguments)
case toolName == "create-db-snapshot":
return m.mockCreateDBSnapshot(arguments)
case toolName == "list-db-instances":
return m.mockListDBInstances(arguments)
case toolName == "list-db-snapshots":
return m.mockListDBSnapshots(arguments)
// Security Group Tools
case toolName == "create-security-group":
return m.mockCreateSecurityGroup(arguments)
case toolName == "list-security-groups":
return m.mockListSecurityGroups(arguments)
case toolName == "add-security-group-ingress-rule":
return m.mockAddSecurityGroupIngressRule(arguments)
case toolName == "add-security-group-egress-rule":
return m.mockAddSecurityGroupEgressRule(arguments)
case toolName == "delete-security-group":
return m.mockDeleteSecurityGroup(arguments)
// Auto Scaling Tools
case toolName == "create-launch-template":
return m.mockCreateLaunchTemplate(arguments)
case toolName == "create-auto-scaling-group":
return m.mockCreateAutoScalingGroup(arguments)
case toolName == "list-auto-scaling-groups":
return m.mockListAutoScalingGroups(arguments)
case toolName == "list-launch-templates":
return m.mockListLaunchTemplates(arguments)
// State Tools
case toolName == "export-infrastructure-state":
return m.mockExportInfrastructureState(arguments)
case toolName == "analyze-infrastructure-state":
return m.mockAnalyzeInfrastructureState(arguments)
case toolName == "visualize-dependency-graph":
return m.mockVisualizeDependencyGraph(arguments)
case toolName == "detect-infrastructure-conflicts":
return m.mockDetectInfrastructureConflicts(arguments)
case toolName == "plan-infrastructure-deployment":
return m.mockPlanInfrastructureDeployment(arguments)
case toolName == "add-resource-to-state":
return m.mockAddResourceToState(arguments)
case toolName == "save-state":
return m.mockSaveState(arguments)
// Utility Tools
case toolName == "get-availability-zones":
return m.mockGetAvailabilityZones(arguments)
default:
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("Mock tool '%s' not implemented", toolName),
},
},
}, nil
}
}
// generateMockToolResponseFallback provides static responses when no AWS client is available
func (m *MockMCPServer) generateMockToolResponseFallback(toolName string, arguments map[string]interface{}) (*mcp.CallToolResult, error) {
switch {
// VPC Tools
case toolName == "create-vpc":
return m.mockCreateVPC(arguments)
case toolName == "list-vpcs":
return m.mockListVPCs(arguments)
case toolName == "get-default-vpc":
return m.mockGetDefaultVPC(arguments)
// Subnet Tools
case toolName == "create-subnet":
return m.mockCreateSubnet(arguments)
case toolName == "create-private-subnet":
return m.mockCreatePrivateSubnet(arguments)
case toolName == "create-public-subnet":
return m.mockCreatePublicSubnet(arguments)
case toolName == "list-subnets":
return m.mockListSubnets(arguments)
case toolName == "list-subnets-for-alb":
return m.mockSelectSubnetsForALB(arguments)
// Networking Infrastructure Tools
case toolName == "create-internet-gateway":
return m.mockCreateInternetGateway(arguments)
case toolName == "create-nat-gateway":
return m.mockCreateNATGateway(arguments)
case toolName == "create-public-route-table":
return m.mockCreatePublicRouteTable(arguments)
case toolName == "create-private-route-table":
return m.mockCreatePrivateRouteTable(arguments)
case toolName == "associate-route-table":
return m.mockAssociateRouteTable(arguments)
case toolName == "add-route":
return m.mockAddRoute(arguments)
// EC2 Tools
case toolName == "create-ec2-instance":
return m.mockCreateEC2Instance(arguments)
case toolName == "list-ec2-instances":
return m.mockListEC2Instances(arguments)
case toolName == "start-ec2-instance":
return m.mockStartEC2Instance(arguments)
case toolName == "stop-ec2-instance":
return m.mockStopEC2Instance(arguments)
case toolName == "terminate-ec2-instance":
return m.mockTerminateEC2Instance(arguments)
case toolName == "create-ami-from-instance":
return m.mockCreateAMIFromInstance(arguments)
case toolName == "list-amis":
return m.mockListAMIs(arguments)
case toolName == "get-latest-ami":
return m.mockGetLatestAMI(arguments)
case toolName == "get-latest-amazon-linux-ami":
return m.mockGetLatestAmazonLinuxAMI(arguments)
case toolName == "get-latest-ubuntu-ami":
return m.mockGetLatestUbuntuAMI(arguments)
// Load Balancer Tools
case toolName == "create-load-balancer":
return m.mockCreateLoadBalancer(arguments)
case toolName == "create-target-group":
return m.mockCreateTargetGroup(arguments)
case toolName == "create-listener":
return m.mockCreateListener(arguments)
case toolName == "list-load-balancers":
return m.mockListLoadBalancers(arguments)
case toolName == "list-target-groups":
return m.mockListTargetGroups(arguments)
case toolName == "register-targets":
return m.mockRegisterTargets(arguments)
case toolName == "deregister-targets":
return m.mockDeregisterTargets(arguments)
// RDS Tools
case toolName == "create-db-subnet-group":
return m.mockCreateDBSubnetGroup(arguments)
case toolName == "create-db-instance":
return m.mockCreateDBInstance(arguments)
case toolName == "start-db-instance":
return m.mockStartDBInstance(arguments)
case toolName == "stop-db-instance":
return m.mockStopDBInstance(arguments)
case toolName == "delete-db-instance":
return m.mockDeleteDBInstance(arguments)
case toolName == "create-db-snapshot":
return m.mockCreateDBSnapshot(arguments)
case toolName == "list-db-instances":
return m.mockListDBInstances(arguments)
case toolName == "list-db-snapshots":
return m.mockListDBSnapshots(arguments)
// Security Group Tools
case toolName == "create-security-group":
return m.mockCreateSecurityGroup(arguments)
case toolName == "list-security-groups":
return m.mockListSecurityGroups(arguments)
case toolName == "add-security-group-ingress-rule":
return m.mockAddSecurityGroupIngressRule(arguments)
case toolName == "add-security-group-egress-rule":
return m.mockAddSecurityGroupEgressRule(arguments)
case toolName == "delete-security-group":
return m.mockDeleteSecurityGroup(arguments)
// Auto Scaling Tools
case toolName == "create-launch-template":
return m.mockCreateLaunchTemplate(arguments)
case toolName == "create-auto-scaling-group":
return m.mockCreateAutoScalingGroup(arguments)
case toolName == "list-auto-scaling-groups":
return m.mockListAutoScalingGroups(arguments)
case toolName == "list-launch-templates":
return m.mockListLaunchTemplates(arguments)
// State Tools
case toolName == "export-infrastructure-state":
return m.mockExportInfrastructureState(arguments)
case toolName == "analyze-infrastructure-state":
return m.mockAnalyzeInfrastructureState(arguments)
case toolName == "visualize-dependency-graph":
return m.mockVisualizeDependencyGraph(arguments)
case toolName == "detect-infrastructure-conflicts":
return m.mockDetectInfrastructureConflicts(arguments)
case toolName == "plan-infrastructure-deployment":
return m.mockPlanInfrastructureDeployment(arguments)
case toolName == "add-resource-to-state":
return m.mockAddResourceToState(arguments)
case toolName == "save-state":
return m.mockSaveState(arguments)
// Utility Tools
case toolName == "get-availability-zones":
return m.mockGetAvailabilityZones(arguments)
default:
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("Mock tool '%s' not implemented", toolName),
},
},
}, nil
}
}
// VPC Mock Responses
func (m *MockMCPServer) mockCreateVPC(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
cidrBlock, _ := arguments["cidrBlock"].(string)
if name == "" {
name = "test-vpc"
}
if cidrBlock == "" {
cidrBlock = "10.0.0.0/16"
}
vpcId := m.generateMockResourceId("vpc")
response := map[string]interface{}{
"vpcId": vpcId,
"name": name,
"cidrBlock": cidrBlock,
"state": "available",
"isDefault": false,
"resource": map[string]interface{}{
"id": vpcId,
"type": "vpc",
"name": name,
},
}
// Store resource for later retrieval
m.resources[vpcId] = &types.AWSResource{
ID: vpcId,
Type: "vpc",
Details: map[string]interface{}{
"name": name,
"cidrBlock": cidrBlock,
"state": "available",
},
}
return m.createSuccessResponse(fmt.Sprintf("VPC '%s' created successfully", name), response)
}
// mockCreateVPCWithAWSClient uses the MockAWSClient for VPC creation
func (m *MockMCPServer) mockCreateVPCWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
cidrBlock, _ := arguments["cidrBlock"].(string)
if name == "" {
name = "test-vpc"
}
if cidrBlock == "" {
cidrBlock = "10.0.0.0/16"
}
// Use the actual AWS mock client
params := aws.CreateVPCParams{
CidrBlock: cidrBlock,
Name: name,
Tags: map[string]string{
"Name": name,
},
}
ctx := context.Background()
awsResource, err := m.awsClient.CreateVPC(ctx, params)
if err != nil {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("Failed to create VPC: %v", err),
},
},
}, err
}
response := map[string]interface{}{
"vpcId": awsResource.ID,
"name": name,
"cidrBlock": cidrBlock,
"state": awsResource.State,
"isDefault": false,
"resource": map[string]interface{}{
"id": awsResource.ID,
"type": awsResource.Type,
"name": name,
"region": awsResource.Region,
},
}
return m.createSuccessResponse(fmt.Sprintf("VPC '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockListVPCs(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
vpcs := []map[string]interface{}{
{
"vpcId": "vpc-default123",
"name": "default-vpc",
"cidrBlock": "172.31.0.0/16",
"state": "available",
"isDefault": true,
},
{
"vpcId": "vpc-prod123",
"name": "production-vpc",
"cidrBlock": "10.0.0.0/16",
"state": "available",
"isDefault": false,
},
}
response := map[string]interface{}{
"vpcs": vpcs,
"count": len(vpcs),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d VPCs", len(vpcs)), response)
}
// mockListVPCsWithAWSClient uses the MockAWSClient for VPC listing
func (m *MockMCPServer) mockListVPCsWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
ctx := context.Background()
awsVPCs, err := m.awsClient.DescribeVPCs(ctx)
if err != nil {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("Failed to list VPCs: %v", err),
},
},
}, err
}
vpcs := make([]map[string]interface{}, 0, len(awsVPCs))
for _, vpc := range awsVPCs {
vpcs = append(vpcs, map[string]interface{}{
"vpcId": vpc.ID,
"name": vpc.Details["name"],
"cidrBlock": vpc.Details["cidrBlock"],
"state": vpc.State,
"isDefault": false, // Mock doesn't track default VPCs
})
}
response := map[string]interface{}{
"vpcs": vpcs,
"count": len(vpcs),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d VPCs", len(vpcs)), response)
}
func (m *MockMCPServer) mockGetDefaultVPC(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
response := map[string]interface{}{
"value": "vpc-default123",
"vpcId": "vpc-default123",
"name": "default-vpc",
"cidrBlock": "172.31.0.0/16",
"state": "available",
"source": "aws_api_call",
}
return m.createSuccessResponse("Found default VPC", response)
}
// Subnet Mock Responses
func (m *MockMCPServer) mockCreateSubnet(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
vpcId, _ := arguments["vpcId"].(string)
cidrBlock, _ := arguments["cidrBlock"].(string)
availabilityZone, _ := arguments["availabilityZone"].(string)
if name == "" {
name = "test-subnet"
}
if vpcId == "" {
vpcId = "vpc-default123"
}
if cidrBlock == "" {
cidrBlock = "10.0.1.0/24"
}
if availabilityZone == "" {
availabilityZone = "us-west-2a"
}
subnetId := m.generateMockResourceId("subnet")
response := map[string]interface{}{
"subnetId": subnetId,
"name": name,
"vpcId": vpcId,
"cidrBlock": cidrBlock,
"availabilityZone": availabilityZone,
"state": "available",
"resource": map[string]interface{}{
"id": subnetId,
"type": "subnet",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Subnet '%s' created successfully", name), response)
}
// mockCreateSubnetWithAWSClient uses the MockAWSClient for subnet creation
func (m *MockMCPServer) mockCreateSubnetWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
vpcId, _ := arguments["vpcId"].(string)
cidrBlock, _ := arguments["cidrBlock"].(string)
availabilityZone, _ := arguments["availabilityZone"].(string)
if name == "" {
name = "test-subnet"
}
if vpcId == "" {
vpcId = "vpc-default123"
}
if cidrBlock == "" {
cidrBlock = "10.0.1.0/24"
}
if availabilityZone == "" {
availabilityZone = "us-west-2a"
}
// Use the actual AWS mock client
params := aws.CreateSubnetParams{
VpcID: vpcId,
CidrBlock: cidrBlock,
AvailabilityZone: availabilityZone,
Name: name,
}
ctx := context.Background()
awsResource, err := m.awsClient.CreateSubnet(ctx, params)
if err != nil {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("Failed to create subnet: %v", err),
},
},
}, err
}
response := map[string]interface{}{
"subnetId": awsResource.ID,
"name": name,
"vpcId": vpcId,
"cidrBlock": cidrBlock,
"availabilityZone": availabilityZone,
"state": awsResource.State,
"resource": map[string]interface{}{
"id": awsResource.ID,
"type": awsResource.Type,
"name": name,
"region": awsResource.Region,
},
}
return m.createSuccessResponse(fmt.Sprintf("Subnet '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockSelectSubnetsForALB(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
scheme, _ := arguments["scheme"].(string)
vpcId, _ := arguments["vpcId"].(string)
if vpcId == "" {
vpcId = "vpc-default123"
}
subnetIds := []string{"subnet-12345", "subnet-67890"}
response := map[string]interface{}{
"subnetIds": subnetIds,
"vpcId": vpcId,
"scheme": scheme,
"count": len(subnetIds),
}
responseText, _ := json.Marshal(response)
return &mcp.CallToolResult{
IsError: false,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: string(responseText),
},
},
}, nil
}
// EC2 Mock Responses
func (m *MockMCPServer) mockGetLatestAMI(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
response := map[string]interface{}{
"value": "ami-latest123",
"imageId": "ami-latest123",
"name": "amzn2-ami-hvm-2.0.20231101.0-x86_64-gp2",
"description": "Amazon Linux 2 AMI",
"source": "aws_api_call",
}
return m.createSuccessResponse("Found latest AMI", response)
}
func (m *MockMCPServer) mockCreateEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
imageId, _ := arguments["imageId"].(string)
instanceType, _ := arguments["instanceType"].(string)
if name == "" {
name = "test-instance"
}
if imageId == "" {
imageId = "ami-latest123"
}
if instanceType == "" {
instanceType = "t3.medium"
}
instanceId := m.generateMockResourceId("i")
response := map[string]interface{}{
"instanceId": instanceId,
"name": name,
"imageId": imageId,
"instanceType": instanceType,
"state": "running",
"resource": map[string]interface{}{
"id": instanceId,
"type": "ec2_instance",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("EC2 instance '%s' created successfully", name), response)
}
// mockCreateEC2InstanceWithAWSClient uses the MockAWSClient for EC2 instance creation
func (m *MockMCPServer) mockCreateEC2InstanceWithAWSClient(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
imageId, _ := arguments["imageId"].(string)
instanceType, _ := arguments["instanceType"].(string)
keyName, _ := arguments["keyName"].(string)
securityGroupId, _ := arguments["securityGroupId"].(string)
subnetId, _ := arguments["subnetId"].(string)
if name == "" {
name = "test-instance"
}
if imageId == "" {
imageId = "ami-12345678" // Valid mock AMI ID format
}
if instanceType == "" {
instanceType = "t3.micro"
}
// Use the actual AWS mock client
params := aws.CreateInstanceParams{
ImageID: imageId,
InstanceType: instanceType,
KeyName: keyName,
SecurityGroupID: securityGroupId,
SubnetID: subnetId,
}
ctx := context.Background()
awsResource, err := m.awsClient.CreateEC2Instance(ctx, params)
if err != nil {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("Failed to create EC2 instance: %v", err),
},
},
}, err
}
response := map[string]interface{}{
"instanceId": awsResource.ID,
"name": name,
"imageId": imageId,
"instanceType": instanceType,
"state": awsResource.State,
"resource": map[string]interface{}{
"id": awsResource.ID,
"type": awsResource.Type,
"name": name,
"region": awsResource.Region,
},
}
return m.createSuccessResponse(fmt.Sprintf("EC2 instance '%s' created successfully", name), response)
}
// Load Balancer Mock Responses
func (m *MockMCPServer) mockCreateLoadBalancer(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
scheme, _ := arguments["scheme"].(string)
lbType, _ := arguments["type"].(string)
if name == "" {
name = "test-alb"
}
if scheme == "" {
scheme = "internet-facing"
}
if lbType == "" {
lbType = "application"
}
loadBalancerArn := fmt.Sprintf("arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/%s/%s",
name, m.generateMockResourceId(""))
response := map[string]interface{}{
"name": name,
"scheme": scheme,
"type": lbType,
"loadBalancerId": loadBalancerArn,
"loadBalancerArn": loadBalancerArn,
"arn": loadBalancerArn,
"resource": map[string]interface{}{
"id": loadBalancerArn,
"type": "load_balancer",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Load balancer '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreateTargetGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
vpcId, _ := arguments["vpcId"].(string)
protocol, _ := arguments["protocol"].(string)
port, _ := arguments["port"].(float64)
if name == "" {
name = "test-tg"
}
if vpcId == "" {
vpcId = "vpc-default123"
}
if protocol == "" {
protocol = "HTTP"
}
if port == 0 {
port = 80
}
targetGroupArn := fmt.Sprintf("arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/%s/%s",
name, m.generateMockResourceId(""))
response := map[string]interface{}{
"name": name,
"vpcId": vpcId,
"protocol": protocol,
"port": int(port),
"targetGroupId": targetGroupArn,
"targetGroupArn": targetGroupArn,
"arn": targetGroupArn,
"resource": map[string]interface{}{
"id": targetGroupArn,
"type": "target_group",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Target group '%s' created successfully", name), response)
}
// State Mock Responses
func (m *MockMCPServer) mockExportInfrastructureState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
return m.stateManager.ExportState(arguments)
}
// Utility Mock Responses
func (m *MockMCPServer) mockGetAvailabilityZones(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
zones := []string{"ap-southeast-1a", "ap-southeast-1b", "ap-southeast-1c"}
response := map[string]interface{}{
"zones": zones,
"count": len(zones),
"allZones": zones,
"allCount": len(zones),
"availabilityZone": zones[0], // First AZ for {{step-id.availabilityZone}} resolution
"value": zones[0], // For {{step-id.resourceId}} resolution
"zone_names": zones, // Alternative access pattern
}
return m.createSuccessResponse(fmt.Sprintf("Retrieved %d availability zones", len(zones)), response)
}
// Utility methods
func (m *MockMCPServer) generateMockResourceId(prefix string) string {
if prefix == "" {
return fmt.Sprintf("%08d", len(m.resources)+1)
}
return fmt.Sprintf("%s-%08d", prefix, len(m.resources)+1)
}
func (m *MockMCPServer) createSuccessResponse(message string, data interface{}) (*mcp.CallToolResult, error) {
responseData, _ := json.Marshal(data)
return &mcp.CallToolResult{
IsError: false,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: string(responseData),
},
},
}, nil
}
// Configuration methods
func (m *MockMCPServer) SimulateError(toolName string, err error) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.simulateErrors[toolName] = err
}
func (m *MockMCPServer) SetCustomResponse(toolName string, response *mcp.CallToolResult) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.customResponses[toolName] = response
}
func (m *MockMCPServer) ClearError(toolName string) {
m.mutex.Lock()
defer m.mutex.Unlock()
delete(m.simulateErrors, toolName)
}
func (m *MockMCPServer) ClearAllErrors() {
m.mutex.Lock()
defer m.mutex.Unlock()
m.simulateErrors = make(map[string]error)
}
// Additional mock methods for missing implementations
func (m *MockMCPServer) mockListSubnets(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
subnets := []map[string]interface{}{
{
"subnetId": "subnet-0def123abc456789",
"name": "default-subnet",
"vpcId": "vpc-default123",
"cidrBlock": "172.31.1.0/24",
"availabilityZone": "us-west-2a",
"state": "available",
},
{
"subnetId": "subnet-12345",
"name": "public-subnet-1",
"vpcId": "vpc-prod123",
"cidrBlock": "10.0.1.0/24",
"availabilityZone": "us-west-2a",
"state": "available",
},
}
// Extract subnet IDs for dependency resolution
subnetIDs := []string{"subnet-0def123abc456789", "subnet-0abc12345678"}
response := map[string]interface{}{
"subnets": subnets, // Subnet details
"subnetId": subnetIDs[0], // First subnet for dependency resolution
"value": subnetIDs[0], // For {{step-id.resourceId}} resolution
"subnet_ids": subnetIDs, // Full list for comprehensive access
}
return m.createSuccessResponse(fmt.Sprintf("Found %d subnets", len(subnets)), response)
}
func (m *MockMCPServer) mockListEC2Instances(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
instances := []map[string]interface{}{
{
"instanceId": "i-sample123",
"name": "sample-instance",
"imageId": "ami-latest123",
"instanceType": "t3.medium",
"state": "running",
},
}
response := map[string]interface{}{
"instances": instances,
"count": len(instances),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d instances", len(instances)), response)
}
func (m *MockMCPServer) mockCreateSecurityGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
vpcId, _ := arguments["vpcId"].(string)
description, _ := arguments["description"].(string)
if name == "" {
name = "test-sg"
}
if vpcId == "" {
vpcId = "vpc-default123"
}
if description == "" {
description = "Test security group"
}
groupId := m.generateMockResourceId("sg")
response := map[string]interface{}{
"groupId": groupId,
"securityGroupId": groupId,
"name": name,
"vpcId": vpcId,
"description": description,
"resource": map[string]interface{}{
"id": groupId,
"type": "security_group",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Security group '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreateListener(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
loadBalancerArn, _ := arguments["loadBalancerArn"].(string)
targetGroupArn, _ := arguments["targetGroupArn"].(string)
protocol, _ := arguments["protocol"].(string)
port, _ := arguments["port"].(float64)
if protocol == "" {
protocol = "HTTP"
}
if port == 0 {
port = 80
}
// Validate ARN formats - be lenient for testing, allow mock IDs
if loadBalancerArn != "" && !strings.HasPrefix(loadBalancerArn, "arn:aws:elasticloadbalancing:") && !strings.HasPrefix(loadBalancerArn, "mock-") {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("loadBalancerArn must be in ARN format, received: '%s'", loadBalancerArn),
},
},
}, nil
}
if targetGroupArn != "" && !strings.HasPrefix(targetGroupArn, "arn:aws:elasticloadbalancing:") && !strings.HasPrefix(targetGroupArn, "mock-") {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: fmt.Sprintf("targetGroupArn must be in ARN format, received: '%s'", targetGroupArn),
},
},
}, nil
}
listenerId := m.generateMockResourceId("listener")
response := map[string]interface{}{
"loadBalancerArn": loadBalancerArn,
"targetGroupArn": targetGroupArn,
"protocol": protocol,
"port": int(port),
"listenerId": listenerId,
"resource": map[string]interface{}{
"id": listenerId,
"type": "listener",
},
}
return m.createSuccessResponse("Listener created successfully", response)
}
// ==== Missing EC2 Mock Methods ====
func (m *MockMCPServer) mockStartEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
instanceId, _ := arguments["instanceId"].(string)
if instanceId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "instanceId is required",
},
},
}, nil
}
response := map[string]interface{}{
"instanceId": instanceId,
"previousState": "stopped",
"currentState": "running",
"resource": map[string]interface{}{
"id": instanceId,
"type": "ec2_instance",
},
}
return m.createSuccessResponse(fmt.Sprintf("Instance %s started successfully", instanceId), response)
}
func (m *MockMCPServer) mockStopEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
instanceId, _ := arguments["instanceId"].(string)
if instanceId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "instanceId is required",
},
},
}, nil
}
response := map[string]interface{}{
"instanceId": instanceId,
"previousState": "running",
"currentState": "stopped",
"resource": map[string]interface{}{
"id": instanceId,
"type": "ec2_instance",
},
}
return m.createSuccessResponse(fmt.Sprintf("Instance %s stopped successfully", instanceId), response)
}
func (m *MockMCPServer) mockTerminateEC2Instance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
instanceId, _ := arguments["instanceId"].(string)
if instanceId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "instanceId is required",
},
},
}, nil
}
response := map[string]interface{}{
"instanceId": instanceId,
"previousState": "running",
"currentState": "terminated",
"resource": map[string]interface{}{
"id": instanceId,
"type": "ec2_instance",
},
}
return m.createSuccessResponse(fmt.Sprintf("Instance %s terminated successfully", instanceId), response)
}
func (m *MockMCPServer) mockCreateAMIFromInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
instanceId, _ := arguments["instanceId"].(string)
name, _ := arguments["name"].(string)
description, _ := arguments["description"].(string)
if instanceId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "instanceId is required",
},
},
}, nil
}
if name == "" {
name = "custom-ami-" + m.generateMockResourceId("ami")
}
amiId := m.generateMockResourceId("ami")
response := map[string]interface{}{
"imageId": amiId,
"name": name,
"description": description,
"sourceInstanceId": instanceId,
"state": "available",
"resource": map[string]interface{}{
"id": amiId,
"type": "ami",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("AMI %s created from instance %s", amiId, instanceId), response)
}
func (m *MockMCPServer) mockListAMIs(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
amis := []map[string]interface{}{
{
"imageId": "ami-latest123",
"name": "amzn2-ami-hvm-2.0.20231101.0-x86_64-gp2",
"description": "Amazon Linux 2 AMI",
"state": "available",
"public": true,
},
{
"imageId": "ami-0abc123def456789",
"name": "ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20231020",
"description": "Canonical, Ubuntu, 22.04 LTS, amd64 jammy image",
"state": "available",
"public": true,
},
}
response := map[string]interface{}{
"images": amis,
"count": len(amis),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d AMIs", len(amis)), response)
}
func (m *MockMCPServer) mockGetLatestAmazonLinuxAMI(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
response := map[string]interface{}{
"amiId": "ami-latest123",
"imageId": "ami-latest123",
"name": "amzn2-ami-hvm-2.0.20231101.0-x86_64-gp2",
"description": "Amazon Linux 2 AMI (HVM) - Kernel 5.10, SSD Volume Type",
"osType": "Linux",
"platform": "amazon-linux",
"architecture": "x86_64",
"state": "available",
"resource": map[string]interface{}{
"id": "ami-latest123",
"type": "ami",
},
}
return m.createSuccessResponse("Found latest Amazon Linux 2 AMI: ami-latest123", response)
}
func (m *MockMCPServer) mockGetLatestUbuntuAMI(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
architecture, _ := arguments["architecture"].(string)
if architecture == "" {
architecture = "x86_64"
}
response := map[string]interface{}{
"amiId": "ami-0abc123def456789",
"imageId": "ami-0abc123def456789",
"name": "ubuntu/images/hvm-ssd/ubuntu-jammy-22.04-amd64-server-20231020",
"description": "Canonical, Ubuntu, 22.04 LTS, amd64 jammy image build on 2023-10-20",
"osType": "Linux",
"platform": "ubuntu",
"architecture": architecture,
"state": "available",
"resource": map[string]interface{}{
"id": "ami-0abc123def456789",
"type": "ami",
},
}
return m.createSuccessResponse("Found latest Ubuntu LTS AMI: ami-0abc123def456789", response)
}
// ==== Missing Networking Mock Methods ====
func (m *MockMCPServer) mockCreatePrivateSubnet(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
vpcId, _ := arguments["vpcId"].(string)
cidrBlock, _ := arguments["cidrBlock"].(string)
availabilityZone, _ := arguments["availabilityZone"].(string)
name, _ := arguments["name"].(string)
if vpcId == "" || cidrBlock == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "vpcId and cidrBlock are required",
},
},
}, nil
}
if name == "" {
name = "private-subnet"
}
if availabilityZone == "" {
availabilityZone = "us-west-2a"
}
subnetId := m.generateMockResourceId("subnet")
response := map[string]interface{}{
"subnetId": subnetId,
"vpcId": vpcId,
"cidrBlock": cidrBlock,
"availabilityZone": availabilityZone,
"name": name,
"mapPublicIpOnLaunch": false,
"state": "available",
"subnetType": "private",
"resource": map[string]interface{}{
"id": subnetId,
"type": "subnet",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Private subnet '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreatePublicSubnet(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
vpcId, _ := arguments["vpcId"].(string)
cidrBlock, _ := arguments["cidrBlock"].(string)
availabilityZone, _ := arguments["availabilityZone"].(string)
name, _ := arguments["name"].(string)
if vpcId == "" || cidrBlock == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "vpcId and cidrBlock are required",
},
},
}, nil
}
if name == "" {
name = "public-subnet"
}
if availabilityZone == "" {
availabilityZone = "us-west-2a"
}
subnetId := m.generateMockResourceId("subnet")
response := map[string]interface{}{
"subnetId": subnetId,
"vpcId": vpcId,
"cidrBlock": cidrBlock,
"availabilityZone": availabilityZone,
"name": name,
"mapPublicIpOnLaunch": true,
"state": "available",
"subnetType": "public",
"resource": map[string]interface{}{
"id": subnetId,
"type": "subnet",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Public subnet '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreateInternetGateway(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
vpcId, _ := arguments["vpcId"].(string)
if name == "" {
name = "test-igw"
}
igwId := m.generateMockResourceId("igw")
response := map[string]interface{}{
"internetGatewayId": igwId,
"name": name,
"state": "available",
"resource": map[string]interface{}{
"id": igwId,
"type": "internet_gateway",
"name": name,
},
}
if vpcId != "" {
response["vpcId"] = vpcId
response["attachmentState"] = "attached"
}
return m.createSuccessResponse(fmt.Sprintf("Internet gateway '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreateNATGateway(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
subnetId, _ := arguments["subnetId"].(string)
name, _ := arguments["name"].(string)
if subnetId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "subnetId is required",
},
},
}, nil
}
if name == "" {
name = "test-nat-gw"
}
natGwId := m.generateMockResourceId("nat")
eipId := m.generateMockResourceId("eip")
response := map[string]interface{}{
"natGatewayId": natGwId,
"subnetId": subnetId,
"name": name,
"state": "available",
"publicIp": "1.2.3.4",
"allocationId": eipId,
"resource": map[string]interface{}{
"id": natGwId,
"type": "nat_gateway",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("NAT gateway '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreatePublicRouteTable(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
vpcId, _ := arguments["vpcId"].(string)
name, _ := arguments["name"].(string)
if vpcId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "vpcId is required",
},
},
}, nil
}
if name == "" {
name = "public-route-table"
}
routeTableId := m.generateMockResourceId("rtb")
response := map[string]interface{}{
"routeTableId": routeTableId,
"vpcId": vpcId,
"name": name,
"routeType": "public",
"resource": map[string]interface{}{
"id": routeTableId,
"type": "route_table",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Public route table '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreatePrivateRouteTable(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
vpcId, _ := arguments["vpcId"].(string)
name, _ := arguments["name"].(string)
if vpcId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "vpcId is required",
},
},
}, nil
}
if name == "" {
name = "private-route-table"
}
routeTableId := m.generateMockResourceId("rtb")
response := map[string]interface{}{
"routeTableId": routeTableId,
"vpcId": vpcId,
"name": name,
"routeType": "private",
"resource": map[string]interface{}{
"id": routeTableId,
"type": "route_table",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Private route table '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockAssociateRouteTable(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
routeTableId, _ := arguments["routeTableId"].(string)
subnetId, _ := arguments["subnetId"].(string)
if routeTableId == "" || subnetId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "routeTableId and subnetId are required",
},
},
}, nil
}
associationId := m.generateMockResourceId("rtbassoc")
response := map[string]interface{}{
"associationId": associationId,
"routeTableId": routeTableId,
"subnetId": subnetId,
"resource": map[string]interface{}{
"id": associationId,
"type": "route_table_association",
},
}
return m.createSuccessResponse("Route table associated successfully", response)
}
func (m *MockMCPServer) mockAddRoute(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
routeTableId, _ := arguments["routeTableId"].(string)
destinationCidrBlock, _ := arguments["destinationCidrBlock"].(string)
gatewayId, _ := arguments["gatewayId"].(string)
natGatewayId, _ := arguments["natGatewayId"].(string)
if routeTableId == "" || destinationCidrBlock == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "routeTableId and destinationCidrBlock are required",
},
},
}, nil
}
if gatewayId == "" && natGatewayId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "either gatewayId or natGatewayId must be specified",
},
},
}, nil
}
response := map[string]interface{}{
"routeTableId": routeTableId,
"destinationCidrBlock": destinationCidrBlock,
"state": "active",
}
if gatewayId != "" {
response["gatewayId"] = gatewayId
response["targetType"] = "gateway"
}
if natGatewayId != "" {
response["natGatewayId"] = natGatewayId
response["targetType"] = "nat-gateway"
}
return m.createSuccessResponse("Route added successfully", response)
}
// ==== Missing Security Group Mock Methods ====
func (m *MockMCPServer) mockListSecurityGroups(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
vpcId, _ := arguments["vpcId"].(string)
securityGroups := []map[string]interface{}{
{
"groupId": "sg-default123",
"groupName": "default",
"description": "default VPC security group",
"vpcId": "vpc-default123",
"inboundRules": []map[string]interface{}{
{
"protocol": "-1",
"fromPort": -1,
"toPort": -1,
"source": "sg-default123",
},
},
"outboundRules": []map[string]interface{}{
{
"protocol": "-1",
"fromPort": -1,
"toPort": -1,
"destination": "0.0.0.0/0",
},
},
},
{
"groupId": "sg-web123",
"groupName": "web-tier",
"description": "Web tier security group",
"vpcId": "vpc-prod123",
"inboundRules": []map[string]interface{}{
{
"protocol": "tcp",
"fromPort": 80,
"toPort": 80,
"source": "0.0.0.0/0",
},
{
"protocol": "tcp",
"fromPort": 443,
"toPort": 443,
"source": "0.0.0.0/0",
},
},
},
}
// Filter by VPC if specified
if vpcId != "" {
filteredGroups := []map[string]interface{}{}
for _, sg := range securityGroups {
if sg["vpcId"].(string) == vpcId {
filteredGroups = append(filteredGroups, sg)
}
}
securityGroups = filteredGroups
}
response := map[string]interface{}{
"securityGroups": securityGroups,
"count": len(securityGroups),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d security groups", len(securityGroups)), response)
}
func (m *MockMCPServer) mockAddSecurityGroupIngressRule(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
groupId, _ := arguments["groupId"].(string)
protocol, _ := arguments["protocol"].(string)
fromPort, _ := arguments["fromPort"].(float64)
toPort, _ := arguments["toPort"].(float64)
cidrBlock, _ := arguments["cidrBlock"].(string)
sourceGroupId, _ := arguments["sourceGroupId"].(string)
if groupId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "groupId is required",
},
},
}, nil
}
if protocol == "" {
protocol = "tcp"
}
rule := map[string]interface{}{
"protocol": protocol,
"fromPort": int(fromPort),
"toPort": int(toPort),
}
if cidrBlock != "" {
rule["source"] = cidrBlock
} else if sourceGroupId != "" {
rule["source"] = sourceGroupId
} else {
rule["source"] = "0.0.0.0/0"
}
response := map[string]interface{}{
"groupId": groupId,
"direction": "ingress",
"rule": rule,
}
return m.createSuccessResponse("Ingress rule added successfully", response)
}
func (m *MockMCPServer) mockAddSecurityGroupEgressRule(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
groupId, _ := arguments["groupId"].(string)
protocol, _ := arguments["protocol"].(string)
fromPort, _ := arguments["fromPort"].(float64)
toPort, _ := arguments["toPort"].(float64)
cidrBlock, _ := arguments["cidrBlock"].(string)
destinationGroupId, _ := arguments["destinationGroupId"].(string)
if groupId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "groupId is required",
},
},
}, nil
}
if protocol == "" {
protocol = "tcp"
}
rule := map[string]interface{}{
"protocol": protocol,
"fromPort": int(fromPort),
"toPort": int(toPort),
}
if cidrBlock != "" {
rule["destination"] = cidrBlock
} else if destinationGroupId != "" {
rule["destination"] = destinationGroupId
} else {
rule["destination"] = "0.0.0.0/0"
}
response := map[string]interface{}{
"groupId": groupId,
"direction": "egress",
"rule": rule,
}
return m.createSuccessResponse("Egress rule added successfully", response)
}
func (m *MockMCPServer) mockDeleteSecurityGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
groupId, _ := arguments["groupId"].(string)
if groupId == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "groupId is required",
},
},
}, nil
}
// Simulate validation - cannot delete default group
if strings.Contains(groupId, "default") {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "Cannot delete default security group",
},
},
}, nil
}
response := map[string]interface{}{
"groupId": groupId,
"status": "deleted",
}
return m.createSuccessResponse(fmt.Sprintf("Security group %s deleted successfully", groupId), response)
}
// ==== Missing Auto Scaling Mock Methods ====
func (m *MockMCPServer) mockCreateLaunchTemplate(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
imageId, _ := arguments["imageId"].(string)
instanceType, _ := arguments["instanceType"].(string)
securityGroupIds, _ := arguments["securityGroupIds"].([]interface{})
if name == "" {
name = "test-launch-template"
}
if imageId == "" {
imageId = "ami-latest123"
}
if instanceType == "" {
instanceType = "t3.micro"
}
templateId := m.generateMockResourceId("lt")
// Convert securityGroupIds to string slice
var sgIds []string
for _, sgId := range securityGroupIds {
if id, ok := sgId.(string); ok {
sgIds = append(sgIds, id)
}
}
response := map[string]interface{}{
"launchTemplateId": templateId,
"name": name,
"imageId": imageId,
"instanceType": instanceType,
"securityGroupIds": sgIds,
"latestVersionNumber": 1,
"resource": map[string]interface{}{
"id": templateId,
"type": "launch_template",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Launch template '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreateAutoScalingGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
launchTemplateId, _ := arguments["launchTemplateId"].(string)
subnetIds, _ := arguments["subnetIds"].([]interface{})
minSize, _ := arguments["minSize"].(float64)
maxSize, _ := arguments["maxSize"].(float64)
desiredCapacity, _ := arguments["desiredCapacity"].(float64)
if name == "" {
name = "test-asg"
}
// Be lenient for testing - generate a mock template ID if not provided
if launchTemplateId == "" {
launchTemplateId = m.generateMockResourceId("launch-template")
}
asgArn := fmt.Sprintf("arn:aws:autoscaling:us-west-2:123456789012:autoScalingGroup:%s:autoScalingGroupName/%s",
m.generateMockResourceId("asg"), name)
// Convert subnetIds to string slice
var subnets []string
for _, subnetId := range subnetIds {
if id, ok := subnetId.(string); ok {
subnets = append(subnets, id)
}
}
response := map[string]interface{}{
"autoScalingGroupName": name,
"autoScalingGroupArn": asgArn,
"launchTemplateId": launchTemplateId,
"subnetIds": subnets,
"minSize": int(minSize),
"maxSize": int(maxSize),
"desiredCapacity": int(desiredCapacity),
"resource": map[string]interface{}{
"id": asgArn,
"type": "auto_scaling_group",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("Auto scaling group '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockListAutoScalingGroups(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
groups := []map[string]interface{}{
{
"autoScalingGroupName": "web-tier-asg",
"autoScalingGroupArn": "arn:aws:autoscaling:us-west-2:123456789012:autoScalingGroup:uuid:autoScalingGroupName/web-tier-asg",
"launchTemplateId": "lt-sample123",
"minSize": 1,
"maxSize": 3,
"desiredCapacity": 2,
"availabilityZones": []string{"us-west-2a", "us-west-2b"},
},
}
response := map[string]interface{}{
"autoScalingGroups": groups,
"count": len(groups),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d auto scaling groups", len(groups)), response)
}
func (m *MockMCPServer) mockListLaunchTemplates(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
templates := []map[string]interface{}{
{
"launchTemplateId": "lt-sample123",
"name": "web-server-template",
"latestVersionNumber": 1,
"defaultVersionNumber": 1,
"imageId": "ami-latest123",
"instanceType": "t3.medium",
},
}
response := map[string]interface{}{
"launchTemplates": templates,
"count": len(templates),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d launch templates", len(templates)), response)
}
// ==== Missing Load Balancer Mock Methods ====
func (m *MockMCPServer) mockListLoadBalancers(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
loadBalancers := []map[string]interface{}{
{
"loadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/test-alb/1234567890123456",
"loadBalancerName": "test-alb",
"scheme": "internet-facing",
"vpcId": "vpc-prod123",
"type": "application",
"state": "active",
"dnsName": "test-alb-123456789.us-west-2.elb.amazonaws.com",
},
}
response := map[string]interface{}{
"loadBalancers": loadBalancers,
"count": len(loadBalancers),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d load balancers", len(loadBalancers)), response)
}
func (m *MockMCPServer) mockListTargetGroups(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
targetGroups := []map[string]interface{}{
{
"targetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/web-servers/1234567890123456",
"targetGroupName": "web-servers",
"protocol": "HTTP",
"port": 80,
"vpcId": "vpc-prod123",
"targetType": "instance",
"healthCheckPath": "/health",
},
}
response := map[string]interface{}{
"targetGroups": targetGroups,
"count": len(targetGroups),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d target groups", len(targetGroups)), response)
}
func (m *MockMCPServer) mockRegisterTargets(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
targetGroupArn, _ := arguments["targetGroupArn"].(string)
targets, _ := arguments["targets"].([]interface{})
if targetGroupArn == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "targetGroupArn is required",
},
},
}, nil
}
var targetList []string
for _, target := range targets {
if targetStr, ok := target.(string); ok {
targetList = append(targetList, targetStr)
}
}
response := map[string]interface{}{
"targetGroupArn": targetGroupArn,
"targets": targetList,
"status": "registered",
}
return m.createSuccessResponse(fmt.Sprintf("Registered %d targets", len(targetList)), response)
}
func (m *MockMCPServer) mockDeregisterTargets(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
targetGroupArn, _ := arguments["targetGroupArn"].(string)
targets, _ := arguments["targets"].([]interface{})
if targetGroupArn == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "targetGroupArn is required",
},
},
}, nil
}
var targetList []string
for _, target := range targets {
if targetStr, ok := target.(string); ok {
targetList = append(targetList, targetStr)
}
}
response := map[string]interface{}{
"targetGroupArn": targetGroupArn,
"targets": targetList,
"status": "deregistered",
}
return m.createSuccessResponse(fmt.Sprintf("Deregistered %d targets", len(targetList)), response)
}
// ==== Missing RDS Mock Methods ====
func (m *MockMCPServer) mockCreateDBSubnetGroup(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
name, _ := arguments["name"].(string)
description, _ := arguments["description"].(string)
subnetIds, _ := arguments["subnetIds"].([]interface{})
if name == "" {
name = "test-db-subnet-group"
}
if description == "" {
description = "Test database subnet group"
}
// Convert subnetIds to string slice
var subnets []string
for _, subnetId := range subnetIds {
if id, ok := subnetId.(string); ok {
subnets = append(subnets, id)
}
}
if len(subnets) == 0 {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "At least one subnet ID is required",
},
},
}, nil
}
response := map[string]interface{}{
"dbSubnetGroupName": name,
"description": description,
"subnetIds": subnets,
"vpcId": "vpc-prod123",
"dbSubnetGroupStatus": "Complete",
"resource": map[string]interface{}{
"id": name,
"type": "db_subnet_group",
"name": name,
},
}
return m.createSuccessResponse(fmt.Sprintf("DB subnet group '%s' created successfully", name), response)
}
func (m *MockMCPServer) mockCreateDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
dbInstanceClass, _ := arguments["dbInstanceClass"].(string)
engine, _ := arguments["engine"].(string)
masterUsername, _ := arguments["masterUsername"].(string)
dbSubnetGroupName, _ := arguments["dbSubnetGroupName"].(string)
allocatedStorage, _ := arguments["allocatedStorage"].(float64)
if dbInstanceIdentifier == "" {
dbInstanceIdentifier = "test-db-instance"
}
if dbInstanceClass == "" {
dbInstanceClass = "db.t3.micro"
}
if engine == "" {
engine = "mysql"
}
if masterUsername == "" {
masterUsername = "admin"
}
if allocatedStorage == 0 {
allocatedStorage = 20
}
endpoint := fmt.Sprintf("%s.cluster-xyz.us-west-2.rds.amazonaws.com", dbInstanceIdentifier)
dbArn := fmt.Sprintf("arn:aws:rds:us-west-2:123456789012:db:%s", dbInstanceIdentifier)
response := map[string]interface{}{
"dbInstanceIdentifier": dbInstanceIdentifier,
"dbInstanceClass": dbInstanceClass,
"engine": engine,
"dbInstanceStatus": "available",
"masterUsername": masterUsername,
"allocatedStorage": int(allocatedStorage),
"dbSubnetGroupName": dbSubnetGroupName,
"endpoint": endpoint,
"port": 3306,
"dbInstanceArn": dbArn,
"resource": map[string]interface{}{
"id": dbInstanceIdentifier,
"type": "db_instance",
"name": dbInstanceIdentifier,
},
}
return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' created successfully", dbInstanceIdentifier), response)
}
func (m *MockMCPServer) mockStartDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
if dbInstanceIdentifier == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "dbInstanceIdentifier is required",
},
},
}, nil
}
response := map[string]interface{}{
"dbInstanceIdentifier": dbInstanceIdentifier,
"previousStatus": "stopped",
"currentStatus": "starting",
"resource": map[string]interface{}{
"id": dbInstanceIdentifier,
"type": "db_instance",
},
}
return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' started successfully", dbInstanceIdentifier), response)
}
func (m *MockMCPServer) mockStopDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
if dbInstanceIdentifier == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "dbInstanceIdentifier is required",
},
},
}, nil
}
response := map[string]interface{}{
"dbInstanceIdentifier": dbInstanceIdentifier,
"previousStatus": "available",
"currentStatus": "stopping",
"resource": map[string]interface{}{
"id": dbInstanceIdentifier,
"type": "db_instance",
},
}
return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' stopped successfully", dbInstanceIdentifier), response)
}
func (m *MockMCPServer) mockDeleteDBInstance(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
skipFinalSnapshot, _ := arguments["skipFinalSnapshot"].(bool)
if dbInstanceIdentifier == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "dbInstanceIdentifier is required",
},
},
}, nil
}
response := map[string]interface{}{
"dbInstanceIdentifier": dbInstanceIdentifier,
"currentStatus": "deleting",
"skipFinalSnapshot": skipFinalSnapshot,
"resource": map[string]interface{}{
"id": dbInstanceIdentifier,
"type": "db_instance",
},
}
return m.createSuccessResponse(fmt.Sprintf("DB instance '%s' deletion initiated", dbInstanceIdentifier), response)
}
func (m *MockMCPServer) mockCreateDBSnapshot(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
dbSnapshotIdentifier, _ := arguments["dbSnapshotIdentifier"].(string)
dbInstanceIdentifier, _ := arguments["dbInstanceIdentifier"].(string)
if dbSnapshotIdentifier == "" || dbInstanceIdentifier == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "Both dbSnapshotIdentifier and dbInstanceIdentifier are required",
},
},
}, nil
}
snapshotArn := fmt.Sprintf("arn:aws:rds:us-west-2:123456789012:snapshot:%s", dbSnapshotIdentifier)
response := map[string]interface{}{
"dbSnapshotIdentifier": dbSnapshotIdentifier,
"dbInstanceIdentifier": dbInstanceIdentifier,
"status": "creating",
"snapshotType": "manual",
"dbSnapshotArn": snapshotArn,
"resource": map[string]interface{}{
"id": dbSnapshotIdentifier,
"type": "db_snapshot",
"name": dbSnapshotIdentifier,
},
}
return m.createSuccessResponse(fmt.Sprintf("DB snapshot '%s' creation initiated", dbSnapshotIdentifier), response)
}
func (m *MockMCPServer) mockListDBInstances(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
instances := []map[string]interface{}{
{
"dbInstanceIdentifier": "production-mysql",
"dbInstanceClass": "db.t3.medium",
"engine": "mysql",
"dbInstanceStatus": "available",
"allocatedStorage": 100,
"endpoint": "production-mysql.cluster-xyz.us-west-2.rds.amazonaws.com",
"port": 3306,
},
{
"dbInstanceIdentifier": "test-postgres",
"dbInstanceClass": "db.t3.micro",
"engine": "postgres",
"dbInstanceStatus": "available",
"allocatedStorage": 20,
"endpoint": "test-postgres.cluster-abc.us-west-2.rds.amazonaws.com",
"port": 5432,
},
}
response := map[string]interface{}{
"dbInstances": instances,
"count": len(instances),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d DB instances", len(instances)), response)
}
func (m *MockMCPServer) mockListDBSnapshots(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
snapshots := []map[string]interface{}{
{
"dbSnapshotIdentifier": "production-mysql-snapshot-2023-10-01",
"dbInstanceIdentifier": "production-mysql",
"status": "available",
"snapshotType": "manual",
"allocatedStorage": 100,
},
}
response := map[string]interface{}{
"dbSnapshots": snapshots,
"count": len(snapshots),
}
return m.createSuccessResponse(fmt.Sprintf("Found %d DB snapshots", len(snapshots)), response)
}
// ==== Missing State Management Mock Methods ====
func (m *MockMCPServer) mockAnalyzeInfrastructureState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
includeMetrics, _ := arguments["includeMetrics"].(bool)
analysis := map[string]interface{}{
"totalResources": 15,
"resourcesByType": map[string]int{
"vpc": 2,
"subnet": 4,
"ec2_instance": 3,
"security_group": 3,
"load_balancer": 1,
"target_group": 1,
"db_instance": 1,
},
"healthStatus": "healthy",
"warnings": []string{
"Security group sg-web123 has overly permissive ingress rules",
},
"recommendations": []string{
"Consider enabling VPC Flow Logs for better network monitoring",
"Review security group rules for least privilege access",
},
}
if includeMetrics {
analysis["metrics"] = map[string]interface{}{
"averageResourceAge": "30 days",
"resourceUtilization": "75%",
"complianceScore": 85,
}
}
response := map[string]interface{}{
"analysis": analysis,
}
return m.createSuccessResponse("Infrastructure state analyzed successfully", response)
}
func (m *MockMCPServer) mockVisualizeDependencyGraph(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
format, _ := arguments["format"].(string)
if format == "" {
format = "mermaid"
}
var visualization string
if format == "mermaid" {
visualization = `graph TD
VPC[vpc-prod123] --> Subnet1[subnet-web-1]
VPC --> Subnet2[subnet-web-2]
Subnet1 --> ALB[test-alb]
Subnet2 --> ALB
ALB --> TG[web-servers]
TG --> EC2_1[i-web-1]
TG --> EC2_2[i-web-2]
VPC --> SG[sg-web123]
SG --> EC2_1
SG --> EC2_2`
} else {
visualization = "Dependency graph visualization not available for format: " + format
}
response := map[string]interface{}{
"format": format,
"visualization": visualization,
"nodeCount": 8,
"edgeCount": 10,
}
return m.createSuccessResponse("Dependency graph generated successfully", response)
}
func (m *MockMCPServer) mockDetectInfrastructureConflicts(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
conflicts := []map[string]interface{}{
{
"type": "security_group_overlap",
"severity": "medium",
"resources": []string{"sg-web123", "sg-app123"},
"description": "Security groups have overlapping port ranges that may cause confusion",
"recommendation": "Review and consolidate security group rules",
},
{
"type": "subnet_cidr_conflict",
"severity": "low",
"resources": []string{"subnet-web-1", "subnet-db-1"},
"description": "Subnets are in different availability zones but have similar naming",
"recommendation": "Use consistent naming convention for subnets",
},
}
response := map[string]interface{}{
"conflicts": conflicts,
"conflictCount": len(conflicts),
"severityCounts": map[string]int{
"high": 0,
"medium": 1,
"low": 1,
},
}
return m.createSuccessResponse(fmt.Sprintf("Found %d infrastructure conflicts", len(conflicts)), response)
}
func (m *MockMCPServer) mockPlanInfrastructureDeployment(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
dryRun, _ := arguments["dryRun"].(bool)
plan := map[string]interface{}{
"totalSteps": 8,
"estimatedDuration": "15 minutes",
"steps": []map[string]interface{}{
{
"step": 1,
"action": "create",
"resourceType": "vpc",
"resourceName": "production-vpc",
"dependencies": []string{},
},
{
"step": 2,
"action": "create",
"resourceType": "subnet",
"resourceName": "web-subnet-1",
"dependencies": []string{"production-vpc"},
},
{
"step": 3,
"action": "create",
"resourceType": "subnet",
"resourceName": "web-subnet-2",
"dependencies": []string{"production-vpc"},
},
{
"step": 4,
"action": "create",
"resourceType": "security_group",
"resourceName": "web-sg",
"dependencies": []string{"production-vpc"},
},
{
"step": 5,
"action": "create",
"resourceType": "load_balancer",
"resourceName": "web-alb",
"dependencies": []string{"web-subnet-1", "web-subnet-2", "web-sg"},
},
},
"warnings": []string{
"This deployment will create resources that incur AWS charges",
},
}
if dryRun {
plan["mode"] = "dry-run"
plan["status"] = "planned"
} else {
plan["mode"] = "execute"
plan["status"] = "ready"
}
response := map[string]interface{}{
"deploymentPlan": plan,
}
return m.createSuccessResponse("Deployment plan generated successfully", response)
}
func (m *MockMCPServer) mockAddResourceToState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
resourceId, _ := arguments["resource_id"].(string)
resourceType, _ := arguments["resource_type"].(string)
resourceData, _ := arguments["properties"].(map[string]interface{})
if resourceId == "" || resourceType == "" {
return &mcp.CallToolResult{
IsError: true,
Content: []mcp.Content{
&mcp.TextContent{
Type: "text",
Text: "resourceId and resourceType are required",
},
},
}, nil
}
// Add to mock state manager
resource := &types.AWSResource{
ID: resourceId,
Type: resourceType,
Details: resourceData,
}
m.resources[resourceId] = resource
response := map[string]interface{}{
"resourceId": resourceId,
"resourceType": resourceType,
"status": "added_to_state",
"resource": resource,
}
return m.createSuccessResponse(fmt.Sprintf("Resource %s added to state successfully", resourceId), response)
}
func (m *MockMCPServer) mockSaveState(arguments map[string]interface{}) (*mcp.CallToolResult, error) {
filePath, _ := arguments["filePath"].(string)
if filePath == "" {
filePath = "infrastructure-state-test.json"
}
resourceCount := len(m.resources)
response := map[string]interface{}{
"filePath": filePath,
"resourceCount": resourceCount,
"timestamp": "2023-10-20T10:30:00Z",
"status": "saved",
}
return m.createSuccessResponse(fmt.Sprintf("State saved to %s with %d resources", filePath, resourceCount), response)
}
// ==== Mock Configuration Methods ====
// SetError configures error simulation for a specific tool
func (m *MockMCPServer) SetError(toolName string, err error) {
m.mutex.Lock()
defer m.mutex.Unlock()
m.simulateErrors[toolName] = err
}
```