Skip to content

Coherence Concepts

A diagram represents the Coherence concepts by demonstrating how an application can contain multiple collections, a collection can contain multiple environments, and an environment can contain multiple services.

Coherence is an internal developer platform that simplifies cloud infrastructure management and application deployment. By understanding its core concepts, you can effectively leverage Coherence to streamline your development workflow and manage complex cloud environments.

Applications

An application is the highest level of organizational unit in Coherence. One application encapsulates all the components, configurations, and resources related to a specific software project or solution. Applications provide a centralized means of managing multiple deployments, environments, and associated cloud resources across various scenarios.

The key features of applications include:

  • Centralized management of multiple deployments
  • Role-based access control (RBAC) for team collaboration
  • Integration with version control systems
  • CNC flavor (reference architecture) selection for the entire application

CNC and reference architectures

Coherence uses CNC to manage the application life cycle. CNC is an open-source framework that handles crucial tasks such as:

  • Provisioning infrastructure
  • Building application components
  • Deploying services

CNC reference architectures, or flavors, define the specific infrastructure choices and deployment strategies for an application. These flavors are selected at the application level and influence service interactions and resource sharing across environments and services. Flavors can be customized to meet various requirements, including:

  • Cost optimization
  • Security and compliance standards
  • Performance tuning
  • Specific cloud provider features

By leveraging CNC and its reference architectures, Coherence provides a flexible yet opinionated approach to cloud application deployment that ensures consistency across entire application ecosystems.

Read more:

Collections

In Coherence, collections are used to group and isolate infrastructure components within applications. A collection functions as a logical organizational unit, similar to the concept of a workspace in Terraform or a cluster in Kubernetes.

No cloud infrastructure is shared between collections in Coherence. This includes, for example, the virtual private cloud (VPC) and VPC security groups.

Multiple collections can be linked to one cloud account, or each collection can be set up within a different account. Collections are typically used to represent distinct deployment targets, such as:

  • Different cloud accounts or regional deployments
  • Separate on-premises environments
  • Isolated customer deployments for multi-tenant solutions

Collections enhance security and resource management by maintaining clear boundaries between different infrastructure setups. With the appropriate cloud identity and access management (IAM) and Coherence RBAC, collections can be used to build a solid foundation for teams to start working quickly while still ensuring the right guardrails are in place.

The most common setup for small teams incorporates two collections, one for non-production workloads (for example, dev, staging, and demo) and another for production. For larger organizations, collections can scale to support complex multi-team, multi-environment setups, ensuring proper isolation and access control.

Read more:

Environments

Multiple environments can be defined within each collection. In Coherence, an environment represents a specific instance of an application, with a unique configuration, code version, and associated resources. Coherence offers three environment types to support the different needs of these application instances.

  • Staging: For staging and development environments
  • Production: For production and demo environments
  • Preview: For testing and generating ephemeral branch preview environments

Environments maintain consistent configurations across different stages of the application life cycle, while providing the flexibility to override settings as needed. Using CNC and Coherence, teams can easily customize environments to match their workflow and deployment processes.

Services

Services are the core building blocks of applications within Coherence. They represent the individual components or microservices that make up an overall solution. Coherence supports various service types to accommodate the different architectural needs of each application.

  • Frontend: For static sites and single-page applications (SPAs)
  • Backend: For containerized applications and APIs
  • Serverless: For function-as-a-service deployments like AWS Lambda
  • Database: For various SQL databases
  • Cache: For in-memory data stores like Redis
  • Bucket: For object storage (S3, GCS)
  • Message Queue: For asynchronous communication
  • DynamoDB: For NoSQL database needs in AWS

Services can be linked to specific code repositories (as many different repos as each app needs) and configured for continuous deployment based on branch updates. Services can also expose environment variables for inter-service communication and configuration. For example, if a database service is configured in an environment, a DATABASE_URL environment variable will be present in the rest of that environment's services during the CI/CD pipelines, as well as when the environment is deployed.

Common examples of a service include:

  • A backend Node.js service (Next.js, Nuxt, Express)
  • A containerized Python server (Django, FastAPI, Flask)
  • A single-page static frontend app or SPA (React, Svelte)
  • A Postgres database server
  • A Redis cache instance

Read more:

Integration capabilities

Coherence and CNC are built to make customization and integration easy for you. Coherence seamlessly integrates with popular development tools and workflows, including:

  • Version control systems (GitHub, GitLab, Bitbucket)
  • CI/CD pipelines
  • Container registries
  • Cloud provider services (AWS, GCP)
  • Monitoring and observability tools (Datadog, Sentry, etc.)

These integrations allow teams to maintain their preferred workflows while leveraging Coherence's powerful infrastructure management capabilities.

Read more:

Summary

The core Coherence concepts - applications, collections, environments, and services - allow organizations of all sizes, from small startups to large enterprises with complex multi-environment setups, to create scalable, secure, and efficient deployment strategies that adapt to their needs.

Glossary

  • CNC: The open-source framework used by Coherence for managing application life cycles.
  • Flavor: A reference architecture in CNC that defines infrastructure and deployment strategies.
  • RBAC: Role-based access control is used to manage permissions within Coherence.
  • CI/CD: Continuous Integration/Continuous Deployment refers to automated processes for building, testing, and deploying applications.

For more detailed information about these concepts, please refer to the linked documentation pages or contact Coherence Support.