Promote Cloud-Native & Platform-Agnostic Thinking

This standard focuses on promoting cloud-native and platform-agnostic thinking, ensuring that systems are designed for flexibility, portability, and resilience, minimizing vendor lock-in and legacy dependencies.

1. Promote Cloud-Native & Platform-Agnostic Thinking:

Embracing cloud-native principles and platform-agnostic architectures is crucial for building systems that are adaptable, resilient, and capable of operating across diverse environments. This approach minimizes vendor lock-in and legacy dependencies, fostering greater flexibility and control.

• 1.1 Multi-Cloud & Hybrid Cloud Design:
  • 1.1.1 Architectural Abstraction:
    • Design systems with architectural abstractions that decouple them from specific cloud provider services.
    • Employ technologies and patterns that are compatible across multiple cloud platforms.
  • 1.1.2 Infrastructure as Code (IaC) Abstraction:
    • Utilise IaC tools that support multi-cloud deployments (e.g., Terraform) to manage infrastructure consistently across providers.
    • Abstract infrastructure configurations to minimize provider-specific dependencies.
  • 1.1.3 Hybrid Cloud Compatibility:
    • Design systems for seamless integration with on-premises and cloud environments.
    • Implement hybrid cloud networking and data synchronization strategies.
• 1.2 Containerisation & Orchestration:
  • 1.2.1 Containerised Applications:
    • Containerise applications using Docker to ensure portability and consistency across environments.
    • Utilise container registries to store and manage container images.
  • 1.2.2 Kubernetes Orchestration:
    • Deploy and manage containerised applications using Kubernetes for orchestration and scalability.
    • Leverage Kubernetes features for service discovery, load balancing, and resource management.
  • 1.2.3 Container Runtime Abstraction:
    • Implement container runtime abstractions (e.g., Container Runtime Interface - CRI) to minimise dependencies on specific container runtimes.
• 1.3 Cloud Service Replaceability:
  • 1.3.1 Interface-Based Design:
    • Design systems with well-defined interfaces that allow for the replacement of cloud services with minimal code changes.
    • Implement service abstraction layers to decouple applications from specific cloud service implementations.
  • 1.3.2 Open Standards & Protocols:
    • Prefer open standards and protocols (e.g., HTTP, gRPC, MQTT) to ensure interoperability with diverse cloud services.
    • Avoid proprietary cloud service APIs that create vendor lock-in.
  • 1.3.3 Data Portability:
    • Implement data portability strategies to facilitate data migration between cloud providers.
    • Utilize standardised data formats and protocols to ensure data accessibility.
• 1.4 Microservices & API-First Approach:
  • 1.4.1 Decoupled Microservices:
    • Design applications as decoupled microservices that can be deployed and scaled independently.
    • Utilise API gateways and service meshes to manage microservice communication.
  • 1.4.2 API-First Design:
    • Adopt an API-first design approach to ensure interoperability and service replaceability.
    • Document APIs using standardised specifications (e.g., OpenAPI, AsyncAPI).
• 1.5 Observability & Monitoring Agnostic:
  • 1.5.1 OpenTelemetry Standard:
    • Implement OpenTelemetry standards to provide vendor-agnostic observability and monitoring.
    • Use OpenTelemetry for tracing, metrics and logging.
  • 1.5.2 Agnostic Monitoring Tools:
    • Utilise monitoring tools that are compatible with multiple cloud providers and on-premise environments.
    • Implement standardised monitoring dashboards and alerting configurations.

By embracing cloud-native and platform-agnostic thinking, organisations can build systems that are adaptable, resilient, and capable of thriving in the dynamic and evolving cloud landscape.