Guidance

aws/guidance/README.md

@@ -0,0 +1,58 @@
+# AWS Cloud Native Development Guidance
+
+## Overview
+
+This guide provides strategic direction for migrating traditional datacenter applications to cloud-native architectures in AWS and AWS GovCloud environments. It addresses key constraints that all cloud solutions must consider and offers specific recommendations based on application types.
+
+## Primary Constraints
+
+When developing cloud-native applications, all solutions must balance these four critical constraints:
+
+1. **Security** - Ensuring data protection, access controls, encryption, and compliance with regulatory standards.
+2. **Cost Efficiency** - Optimizing resource usage and implementing automated scaling to match demand.
+3. **Scalability** - Building systems that can handle growth without significant re-architecture.
+4. **Stability** - Designing for high availability, fault tolerance, and recoverability.
+
+## Guidance Documents
+
+This collection is organized into the following specialized guides:
+
+- [Application Migration Patterns](./application-patterns.md) - Specific recommendations for migrating common application architectures to AWS
+- [CI/CD Implementation Guide](./cicd-implementation.md) - Best practices for implementing continuous integration and delivery pipelines
+- [Cloud Resource Equivalents](./resource-equivalents.md) - Mapping traditional datacenter resources to their AWS counterparts
+- [AWS Services Guide](./services-guide.md) - When to use specific AWS services for maximum benefit
+- [AWS GovCloud Considerations](./govcloud-considerations.md) - Important differences when implementing in GovCloud environments
+- [Cloud-Native Best Practices](./best-practices.md) - General recommendations for successful cloud implementations
+
+## Getting Started
+
+1. **Assessment**
+   - Inventory applications and requirements
+   - Identify dependencies and integrations
+   - Determine migration priorities
+
+2. **Training**
+   - Complete AWS foundational training
+   - Develop cloud architecture skills
+   - Create centers of excellence
+
+3. **Proof of Concept**
+   - Start with non-critical applications
+   - Validate architectural decisions
+   - Document lessons learned
+
+4. **Migration Planning**
+   - Develop detailed migration strategies
+   - Create rollback plans
+   - Establish success criteria
+
+5. **Continuous Improvement**
+   - Review cloud usage and optimize
+   - Stay current with new services
+   - Refine architecture based on experience
+
+## References
+
+- [AWS Architecture Center](https://aws.amazon.com/architecture/)
+- [AWS Well-Architected Framework](https://aws.amazon.com/architecture/well-architected/)
+- [Cloud Adoption Framework](https://aws.amazon.com/professional-services/CAF/)

aws/guidance/application-architecture-decision-tree.md

@@ -0,0 +1,187 @@
+# AWS Application Architecture Decision Tree
+
+This guide provides a structured approach to determine the most appropriate AWS architecture for your application based on its characteristics and requirements.
+
+## Introduction
+
+Different applications have different infrastructure needs based on their technical requirements, usage patterns, and organizational constraints. This decision tree will help you identify the best AWS architecture pattern for your specific application.
+
+## How to Use This Guide
+
+1. Start with the core application characteristics section
+2. Answer each question about your application
+3. Follow the path based on your answers
+4. Review the recommended architecture pattern
+5. Refer to the detailed implementation guidance in the [Application Migration Patterns](application-patterns.md) document
+
+## Core Application Characteristics
+
+### 1. Application Type
+
+Start by identifying your application type:
+
+```mermaid
+flowchart TD
+    A[Application Type] --> B{Is it a web application?}
+    B -->|Yes| C{Frontend technology?}
+    B -->|No| D{Is it a batch processing job?}
+    C -->|PHP| E[LAMP Stack - Pattern #1]
+    C -->|JavaScript/Node.js| F[MEAN Stack - Pattern #9]
+    C -->|.NET/Windows| G[Windows/.NET - Pattern #13]
+    C -->|Containerized| H{Stateful?}
+    H -->|Yes| I[Containerized Stateful - Pattern #11]
+    H -->|No| J[Containerized Stateless - Pattern #12]
+    D -->|Yes| K{Memory intensive?}
+    D -->|No| L{Is it a scheduled task/script?}
+    K -->|Yes| M[Memory-Intensive Batch - Pattern #5]
+    K -->|No| N[Containerized Short Processing - Pattern #10]
+    L -->|Yes| O[Scheduled Script Execution - Pattern #2]
+    L -->|No| P{Is it a microservice?}
+    P -->|Yes| Q[Microservice Architecture - Pattern #14]
+    P -->|No| R{Is it a COTS product?}
+    R -->|Yes| S[COTS Product - Pattern #6]
+    R -->|No| T{Does it need GUI access?}
+    T -->|Yes| U[GUI-Based Application - Pattern #19]
+    T -->|No| V{Primary purpose?}
+```
+
+### 2. Data Requirements
+
+Next, evaluate your data requirements:
+
+```mermaid
+flowchart TD
+    A[Data Requirements] --> B{What type of data storage?}
+    B -->|Relational Database| C{Size/Performance needs?}
+    B -->|NoSQL/Document DB| D[Consider DynamoDB or DocumentDB]
+    B -->|File Storage| E{Access pattern?}
+    B -->|Time Series| F[Time Series Pattern - Pattern #15]
+    B -->|Large Shared Data| G[Large Shared Data - Pattern #4]
+    B -->|Media Files| H[Media Repository - Pattern #23]
+    C -->|Standard| I[RDS MySQL/PostgreSQL]
+    C -->|High Performance| J[Aurora]
+    C -->|Enterprise/Legacy| K[RDS SQL Server/Oracle]
+    E -->|Windows SMB| L[FSx for Windows - Pattern #16]
+    E -->|Linux| M[EFS]
+    E -->|High Performance| N[FSx for Lustre - Pattern #18]
+```
+
+### 3. Scalability & Performance
+
+Assess your scalability and performance requirements:
+
+```mermaid
+flowchart TD
+    A[Scalability Requirements] --> B{Anticipated load pattern?}
+    B -->|Variable/Unpredictable| C{Stateless application?}
+    B -->|Stable/Predictable| D[EC2 with ASG]
+    B -->|Infrequent/On-demand| E[Serverless]
+    C -->|Yes| F{Response time critical?}
+    C -->|No| G[ECS/EKS with persistent storage]
+    F -->|Yes| H[EC2 with ASG]
+    F -->|No| I[Fargate or Lambda]
+    E -->|Data processing| J[Lambda - Pattern #2]
+    E -->|API serving| K[API Gateway + Lambda]
+```
+
+### 4. Operational Requirements
+
+Consider your operational needs:
+
+```mermaid
+flowchart TD
+    A[Operational Requirements] --> B{DevOps maturity?}
+    B -->|High| C[Container-based - Pattern #11/#12]
+    B -->|Medium| D[Elastic Beanstalk]
+    B -->|Low| E[Managed Services]
+    A --> F{Deployment frequency?}
+    F -->|Multiple times daily| G[CI/CD Pipeline - Pattern #22]
+    F -->|Weekly/Monthly| H[Blue/Green deployment]
+    F -->|Infrequent| I[Standard deployment]
+    A --> J{Monitoring needs?}
+    J -->|Basic| K[CloudWatch]
+    J -->|Advanced| L[CloudWatch + X-Ray]
+    J -->|Enterprise| M[Managed Prometheus/Grafana]
+```
+
+### 5. Security & Compliance
+
+Evaluate your security and compliance requirements:
+
+```mermaid
+flowchart TD
+    A[Security & Compliance] --> B{Data classification?}
+    B -->|Highly Sensitive| C[GovCloud - Pattern #30]
+    B -->|Sensitive| D[VPC with no public access]
+    B -->|Standard| E[Standard AWS security]
+    A --> F{Compliance regime?}
+    F -->|FedRAMP| G[GovCloud with specific controls]
+    F -->|PCI-DSS| H[Segmented environment with specific controls]
+    F -->|HIPAA| I[Encrypted data + access controls]
+    F -->|Internal| J[Security Working Group - Pattern #27]
+    A --> K{Multi-tenant?}
+    K -->|Yes| L[Multi-tenant architecture - Pattern #8]
+    K -->|No| M[Dedicated resources]
+```
+
+## Decision Matrix
+
+If you're still unsure after following the decision tree, use this matrix to match your application characteristics to the appropriate architecture pattern:
+
+| Characteristic | High Priority Concerns | Recommended Patterns |
+|---------------|------------------------|---------------------|
+| Web Application | Scalability, Cost-efficiency | #1, #9, #12, #21 |
+| Batch Processing | Computing power, Memory | #2, #5, #10 |
+| Data Analysis | Storage, Processing power | #3, #4, #15 |
+| Legacy Application | Compatibility, Minimal changes | #6, #13, #24 |
+| Microservices | Isolation, Independent scaling | #12, #14 |
+| High Security | Compliance, Access control | #7, #27, #30 |
+| Developer Platform | Self-service, Standardization | #31, #33, #34 |
+| Public-facing | Performance, Availability | #21, #23 |
+| Third-party | Licensing, Support | #6, #24, #25 |
+
+## Next Steps
+
+1. Identify your application's pattern from this decision tree
+2. Refer to the detailed guidance for your pattern in the [Application Migration Patterns](application-patterns.md) document
+3. Use the references provided to explore AWS documentation for specific services
+4. Consider a proof of concept to validate the architecture
+5. Engage with cloud architects for design review if needed
+
+## Example Scenarios
+
+### Example 1: Customer-facing E-commerce Website
+- Web application: Yes
+- Frontend: PHP
+- Data: Relational (product catalog) + File storage (product images)
+- Load: Variable with seasonal spikes
+- Security: PCI-DSS compliance for payments
+- **Recommendation**: LAMP Stack (Pattern #1) with CloudFront CDN, with specific security controls for PCI compliance
+
+### Example 2: Nightly Data Processing Job
+- Web application: No
+- Batch processing: Yes
+- Memory intensive: Yes (processes large datasets)
+- Scheduled: Yes (runs each night)
+- **Recommendation**: Memory-Intensive Batch Processing (Pattern #5) using AWS Batch
+
+### Example 3: Internal Admin Dashboard
+- Web application: Yes
+- Frontend: JavaScript (React)
+- Backend: Node.js API
+- Data: MongoDB
+- Access: Internal users only
+- **Recommendation**: MEAN Stack (Pattern #9) deployed in private subnets
+
+### Example 4: Legacy Windows Application
+- Application type: Desktop application
+- Platform: Windows
+- Database: SQL Server
+- User access: Remote workers need access
+- **Recommendation**: GUI-Based Application (Pattern #19) using AppStream 2.0
+
+## Conclusion
+
+This decision tree provides a starting point for determining the most appropriate AWS architecture pattern for your application. Every application has unique requirements, so it's important to evaluate the recommendations in the context of your specific needs and constraints.
+
+For detailed implementation guidance on each pattern, refer to the [Application Migration Patterns](application-patterns.md) document.