Skip to content

Coherence Concepts

concepts image

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.

Application

An application in Coherence represents the highest-level organizational unit. It encapsulates all the components, configurations, and resources related to a specific software project or solution. Applications provide a centralized way to manage multiple deployments, environments, and associated cloud resources across various scenarios.

Key features:

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

cnc and Reference Architectures

Coherence utilizes cnc, an open-source framework, to manage the application lifecycle. cnc handles crucial tasks such as:

  • Provisioning infrastructure
  • Building application components
  • Deploying services

Reference architectures in cnc define the specific infrastructure choices and deployment strategies for your applications. These flavors are selected at the application level and influence how services interact and what resources are shared between environments and services within collections. Flavors can be customized to meet various requirements, such as:

  • 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 your entire application ecosystem.

Read more:

Collection

Collections in Coherence offer a way to logically group and isolate infrastructure components. They're similar to the concept of workspaces in terraform or clusters in Kubernetes. No cloud infrastructure is shared (including for example the VPC and security groups) between collections in Coherence. You can have many collections in one cloud account, or each one in a different account. Each collection typically represents a distinct deployment target, such as:

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

Collections help maintain clear boundaries between different infrastructure setups, enhancing security and resource management. The most common setup for small teams has 2 collections, one for non-production workloads such as dev/staging/demo, and another for production. Using the appropriate cloud IAM and Coherence RBAC, you're able to quickly get to a solid foundation for teams to work quickly while still putting the right guardrails in place.

For larger organizations, collections can scale to support complex multi-team, multi-environment setups, ensuring proper isolation and access control.

Read more:

Environment

Within each collection, you can define multiple environments. An environment represents a specific instance of your application with its unique configuration, code version, and associated resources. Common examples include:

  • Development
  • Staging
  • Production
  • Demo
  • Ephemeral branch preview environments for testing

Environments allow you to maintain consistent configurations across different stages of your application lifecycle while providing the flexibility to override settings as needed. Several types are available such as preview/ephemeral, staging, and production. Using cnc and Coherence, you can easily match your team's workflow and deployment processes.

Read more:

Service

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

  • Frontend: For static sites and single-page applications (SPAs)
  • Backend: For containerized applications and APIs
  • Serverless: For function-as-a-service deployments (e.g. AWS Lambda)
  • Database: Supporting 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 (you can use as many different repos in each app as you need) and can be configured for continuous deployment based on branch updates. They can also expose environment variables for inter-service communication and configuration. For example, if you configure a database service in an environment, DATABASE_URL is present in the other services during the CI/CD pipelines as well as when 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 enable teams to maintain their preferred workflows while leveraging Coherence's powerful infrastructure management capabilities.

Read more:

Summary

Understanding these core Coherence concepts - Applications, Collections, Environments, and Services - is crucial for effectively managing your applications. By leveraging these concepts, you can create scalable, secure, and efficient deployment strategies that adapt to your organization's needs, from small startups to large enterprises with complex multi-environment setups.

Glossary

  • cnc: The open-source framework used by Coherence for managing application lifecycles
  • Flavor: A reference architecture in cnc that defines infrastructure and deployment strategies
  • RBAC: Role-Based Access Control, used for managing permissions within Coherence
  • CI/CD: Continuous Integration/Continuous Deployment, automated processes for building, testing, and deploying applications

For more detailed information on any of these concepts, please refer to the linked documentation pages or contact our support team.