question
stringlengths 107
306
| answer
stringlengths 210
1.01k
| source
stringlengths 35
111
| topic
stringlengths 5
68
|
|---|---|---|---|
How can I find a specific internal API, like an `OrderProcessingAPI`, within the Choreo Marketplace if I only know its name or a keyword from its description?
|
To find a specific service like your `OrderProcessingAPI`, you can use the top search bar in the Choreo Marketplace. You can search by the service's `Name`, `Label`, or `Content` (which includes its overview, summary, and documentation). If you're unsure which attribute contains the keyword, you can select `All` to search across all these criteria simultaneously.
|
docs\choreo-concepts\choreo-marketplace.md/Discover services
|
Discover services
|
I'm looking for all services that my team has deployed internally within Choreo, not any third-party integrations. How do I filter the Marketplace to see only these?
|
You can use the left-hand side filter panel in the Choreo Marketplace. Under the `Type` filter, select the `Internal` option. This will display only the services that have been deployed within Choreo by your organization.
|
docs\choreo-concepts\choreo-marketplace.md/Discover services
|
Discover services
|
My team has deployed a new `CustomerData` service, and we want to ensure it's only accessible within our specific project, not the entire organization or publicly. How can I verify its visibility in the Marketplace?
|
To verify the network visibility of your `CustomerData` service, you can use the `Network Visibility` filter in the left-hand side filter panel of the Choreo Marketplace. Select the `Project` option to see services exposed only at the project level. This will help you confirm if your service is correctly configured for project-level exposure.
|
docs\choreo-concepts\choreo-marketplace.md/Discover services
|
Discover services
|
After finding a `PaymentGatewayService` in the Marketplace, how can I view its API contract (e.g., OpenAPI specification) to understand its endpoints and data models before integrating it into my Node.js application?
|
Once you click on the `PaymentGatewayService` card to open its detailed view, navigate to the `API definition` tab. This tab includes the API definition for the service, which is extracted from the `component.yaml` file in the user repository. If an API definition was not provided by the developer, this tab will be empty.
|
docs\choreo-concepts\choreo-marketplace.md/Explore a service
|
Explore a service
|
I've identified a `NotificationService` in the Marketplace that I want to use in my new Python FastAPI application. Where can I find specific instructions on how to connect to and consume this service?
|
After clicking on the `NotificationService` card to view its details, go to the `How to use` tab. This section provides instructions on how to use the selected service, including guidance on creating a connection to it from your component.
|
docs\choreo-concepts\choreo-marketplace.md/Explore a service
|
Explore a service
|
I'm a service developer and I've just deployed my `InventoryManagement` service. How do I ensure that the 'Overview' section on its Marketplace entry is populated with useful information for other developers, and where can I add additional related documents?
|
To populate the `Overview` section for your `InventoryManagement` service, you need to provide the overview content via the `Manage → Marketplace` section of your component. Similarly, any additional content you want to include as documents (e.g., detailed guides, FAQs) can be added through the same `Manage → Marketplace` section, and they will appear under the `Related documents` tab in the service's detailed view.
|
docs\choreo-concepts\choreo-marketplace.md/Explore a service
|
Explore a service
|
I've just deployed a new `UserAuthentication` service component with an endpoint to its initial environment in Choreo. Do I need to perform any manual steps to make it discoverable in the Choreo Marketplace?
|
No, you do not need to manually add it. Upon deployment to the initial environment, Choreo services are automatically added to the Marketplace. Choreo effortlessly collects essential details like the component name, endpoint name, description, and service definitions during this deployment to generate the corresponding service entry.
|
docs\choreo-concepts\choreo-marketplace.md/Add a service to the Choreo Marketplace
|
Add a service to the Choreo Marketplace
|
My `OrderProcessing` service depends on a `ShippingAPI` service, which is available in the Choreo Marketplace as `v1`. If the `ShippingAPI` team later releases `v1.3` (a minor version update), will my `OrderProcessing` service automatically start using `v1.3` without me needing to update anything?
|
Yes, it will. Choreo's semantic-version-based intelligent routing ensures that when you use a service from the Marketplace as a dependency, your dependent service's traffic automatically routes to the latest version of the corresponding service within the same major version. So, if `ShippingAPI` `v1.3` is released, your `OrderProcessing` service will automatically connect to `v1.3`.
|
docs\choreo-concepts\choreo-marketplace.md/Semantic-version-based intelligent routing in the Choreo Marketplace
|
Semantic-version-based intelligent routing in the Choreo Marketplace
|
I see `v1` and `v2` entries for a `ProductCatalog` service in the Choreo Marketplace. If the actual deployed versions are `v1.0`, `v1.1`, `v1.2`, and `v2.0`, which specific versions do the `v1` and `v2` entries in the Marketplace represent?
|
In the Choreo Marketplace, service versions are displayed in their major version format, representing the *latest* version of the service within that major version. Therefore, the `v1` entry would represent `v1.2` (the latest within the `v1` major version), and the `v2` entry would represent `v2.0` (the latest within the `v2` major version).
|
docs\choreo-concepts\choreo-marketplace.md/Service versioning in the Choreo Marketplace
|
Service versioning in the Choreo Marketplace
|
I've updated the description and network visibility settings for my `UserManagement` service component in Choreo. Do I need to manually update its entry in the Choreo Marketplace, or will these changes be reflected automatically?
|
No, you don't need to manually update it. When you redeploy your `UserManagement` service to any environment, Choreo automatically updates its service definitions, visibility, and descriptions in the Marketplace to reflect the latest changes.
|
docs\choreo-concepts\choreo-marketplace.md/Edit services in the Choreo Marketplace
|
Edit services in the Choreo Marketplace
|
I'm deploying my first Ballerina microservice to Choreo. What's the initial deployment step I need to take to get it running in the development environment, and can I automate subsequent builds?
|
For your first Ballerina component deployment, you must manually trigger the initial build. This ensures that Choreo applies all necessary configurations to the development environment. After this initial manual build, you can then enable 'Auto Build on Commit' to automatically trigger builds for subsequent commits.
|
docs\choreo-concepts\ci-cd.md/Deployment
|
Deployment
|
My Java Spring Boot application needs different database connection strings for development and production environments. How do I manage these environment-specific configurations in Choreo?
|
To manage environment-specific configurations for your Java Spring Boot application, navigate to the 'Deploy' page of your component in Choreo. From there, locate the card corresponding to the specific environment (e.g., 'Development' or 'Production'), make your necessary configuration changes (like updating database connection strings), and then trigger a new deployment for that environment. These configurations are injected at runtime and are kept separate from your source code.
|
docs\choreo-concepts\ci-cd.md/Configurations
|
Configurations
|
I want to set up a fully automated CI/CD pipeline for my Node.js API in Choreo so that every time I push a commit, it builds and deploys automatically. How do I achieve this?
|
To set up a fully automated CI/CD pipeline for your Node.js API, you need to enable two features in Choreo. First, on the 'Build' page, enable 'Auto Build on Commit'. This will automatically trigger a build for every new commit. Second, on the 'Deploy' page, go to the 'Set Up' card and enable 'Auto Deploy on Build'. This will automatically initiate deployment once an automatic build completes. Note that 'Auto Deploy on Build' requires 'Auto Build on Commit' to be enabled.
|
docs\choreo-concepts\ci-cd.md/Build
|
Build
|
I have an external API key for my Python Flask application that I need to inject at runtime. How can I securely store and inject this secret into my Choreo-deployed service?
|
Choreo allows you to inject configurations and secrets, such as external API keys, at the environment level during runtime. These are stored in a secure vault, encrypted at rest and in transit. To manage these, you would define them as environment-specific configurations. Go to the 'Deploy' page, select the specific environment card, and add your API key there. Choreo will then inject this secret into your Python Flask application at runtime, ensuring strict separation from your source code.
|
docs\choreo-concepts\ci-cd.md/Configurations
|
Configurations
|
After successfully testing my Go microservice in the development environment, I want to promote the exact same build to the production environment. What's the process for doing this in Choreo?
|
Choreo follows a 'build once, deploy many' strategy. Once your Go microservice's image is built and tested in a lower environment like development, you can promote that *same* built container image to higher environments. To do this, navigate to the 'Deploy' page of your component in Choreo, and you will find options to manually promote the component across environments.
|
docs\choreo-concepts\ci-cd.md/Deployment
|
Deployment
|
My recent build for my Dockerfile-based component failed. How can I check the build logs to understand why it failed?
|
To view the build logs for your Dockerfile-based component, go to the 'Build' page in Choreo. On this page, you can see a list of your specific builds. To view the detailed logs for a particular failed build, simply click on 'View Details' corresponding to that specific build entry.
|
docs\choreo-concepts\ci-cd.md/Build
|
Build
|
I need to redeploy a specific, older version of my service that was built from a particular Git commit. How can I ensure Choreo builds and deploys that exact version again?
|
Choreo supports repeatable builds, meaning it can replicate builds from an identical Git commit, generating Docker images with the same behavior. To build a specific older version, go to the 'Build' page and instead of clicking 'Build Latest', you have the option to select a particular commit from your Git repository and trigger a build for that specific code version.
|
docs\choreo-concepts\ci-cd.md/Build
|
Build
|
How does Choreo ensure my users don't experience downtime when I deploy a new version of my React frontend's backend API?
|
Choreo ensures zero downtime during deployments and promotions by performing rolling updates. When a new build of your React frontend's backend API is deployed, Choreo conducts a health check on the new version. Only after the new build passes its health checks is traffic switched to it from the currently running version, preventing any service interruption for your users.
|
docs\choreo-concepts\ci-cd.md/Zero-downtime deployments
|
Zero-downtime deployments
|
I have a custom Dockerfile for my Rust application. How do I ensure Choreo uses my Dockerfile to build the container image instead of auto-generating one?
|
Choreo's build pipelines are designed to build a container image either from the provided source code or from a given Dockerfile. If you have a custom Dockerfile for your Rust application, Choreo will use it to build your container image. You simply need to ensure your Dockerfile is part of your provided source code repository.
|
docs\choreo-concepts\ci-cd.md/Build
|
Build
|
Can I integrate my unit tests for my Java application directly into Choreo's build pipeline, and if so, how?
|
Yes, Choreo's buildpacks support integrating unit tests directly into the build pipeline for certain component types. While the document mentions referring to 'Integrate Unit Tests into the Build Pipeline' for more details, the general process involves configuring your build pipeline to execute your unit tests as part of the build process before the container image is pushed to the registry.
|
docs\choreo-concepts\ci-cd.md/Build
|
Build
|
I have a Python Flask microservice in a specific directory within my Git repository. How do I deploy this as a component in Choreo?
|
To deploy your Python Flask microservice, you would define it as a component in Choreo. A component is linked to a specific directory path in your Git repository that contains your program source code. Choreo will then use this source code to build and deploy your microservice as a single unit of work.
|
docs\choreo-concepts\component.md/Component
|
Component
|
My Go application requires specific build steps defined in a custom Dockerfile. How can I ensure Choreo uses my Dockerfile instead of its default build process when deploying my component?
|
Choreo components can be attached to a Git repository path that contains a Dockerfile with build instructions. By placing your custom Dockerfile in the specified directory, Choreo will utilize it to build your component, ensuring your specific build steps are followed.
|
docs\choreo-concepts\component.md/Component
|
Component
|
I've deployed my Node.js API as a service component in Choreo. If I experience a sudden surge in user traffic, how can I scale this specific API independently to handle the load?
|
Since each component in Choreo maps to a single pod in the Kubernetes cluster at deployment time, you can deploy, manage, and scale each component independently. This means you can scale your Node.js API component up or down without affecting other components in your project.
|
docs\choreo-concepts\component.md/Component
|
Component
|
I need to set up a daily data synchronization job using a Java application. Which Choreo component type should I choose for this, and how do I configure it to run every day at a specific time?
|
For a daily data synchronization job, you should use a 'scheduled integration' component type. This type is designed for jobs/tasks and allows you to configure a cron expression to schedule its execution at specific times, such as daily.
|
docs\choreo-concepts\component.md/Component
|
Component
|
I'm developing a React single-page application (SPA). What Choreo component type is most suitable for hosting this frontend application, and how does it differ from deploying a backend API?
|
For hosting a React single-page application, you would typically use a 'web application' component type. Choreo supports various component types like 'services' (for APIs), 'API proxies', and 'web applications', each with unique features tailored to their characteristics. A web application component would be optimized for serving static or client-side rendered content, whereas a service component is for exposing APIs.
|
docs\choreo-concepts\component.md/Component
|
Component
|
The documentation states that each Choreo component maps to a single Kubernetes pod. What are the practical implications of this for my deployed Python microservice regarding resource allocation and isolation?
|
The mapping of each Choreo component to a single Kubernetes pod means that your Python microservice will run within its own isolated environment. This provides dedicated resource allocation for your component and allows for independent deployment, management, and scaling, ensuring that actions on one component do not directly impact others.
|
docs\choreo-concepts\component.md/Component
|
Component
|
How do I connect my Node.js microservice deployed on Choreo to an external PostgreSQL database hosted on AWS RDS, ensuring secure access to the connection string?
|
To connect your Node.js microservice to an external PostgreSQL database like one on AWS RDS, you would utilize Choreo's 'Connections' feature. First, you create a connection to your AWS RDS instance within Choreo. Choreo will then provide a Connection ID along with a set of connection parameters (e.g., host, port, username, password, database name). You must then configure your Choreo component (your Node.js microservice) to map these connection parameters to specific environment variable names (e.g., `DB_HOST`, `DB_USER`, `DB_PASSWORD`). At runtime, Choreo dynamically injects the actual values into these environment variables. In your Node.js application, you would then programmatically retrieve these values using `process.env.DB_HOST`, `process.env.DB_USER`, etc., to construct your database connection string and establish the connection. This method ensures that connection details are loosely coupled from your service implementation.
|
docs\choreo-concepts\connections.md/Connections
|
Connections
|
My Python FastAPI backend needs to send SMS messages via Twilio, and I anticipate other Python or Java microservices within the same Choreo project might also need to use Twilio in the future. What's the best way to set up this Twilio integration for project-wide reuse?
|
For a third-party service like Twilio that you intend to share and reuse across multiple components within the same Choreo project, the recommended approach is to create a 'Project Connection'. Project Connections are designed to be used by any component within that particular project. After creating the Project Connection for Twilio, Choreo will provide a Connection ID and relevant parameters (e.g., Twilio Account SID, Auth Token). You will then configure each component (like your Python FastAPI service or future Java microservices) to map these connection parameters to environment variable names (e.g., `TWILIO_ACCOUNT_SID`, `TWILIO_AUTH_TOKEN`). Your Python FastAPI service can then read these environment variables using `os.environ.get('TWILIO_ACCOUNT_SID')` to initialize the Twilio client. This setup allows all components to refer to the same Twilio connection using its ID, promoting reuse and consistency across your project.
|
docs\choreo-concepts\connections.md/Project Connections
|
Project Connections
|
I have two Java Spring Boot microservices, `OrderService` and `PaymentService`, deployed within the same Choreo project. `OrderService` needs to retrieve payment status from `PaymentService`. How should I establish this inter-service communication securely and efficiently within Choreo?
|
To enable `OrderService` to securely and efficiently consume `PaymentService` when both are deployed within the same Choreo project, you should create a 'Project Connection'. This type of connection is ideal for integrating services within the same project, allowing `OrderService` to connect to `PaymentService` as a Choreo service. Choreo will provide a Connection ID and necessary connection parameters for `PaymentService`. You will then map these parameters to environment variables within `OrderService`'s configuration. At runtime, `OrderService` can read these environment variables (e.g., using `System.getenv("PAYMENT_SERVICE_URL")`) to programmatically establish the connection. A significant benefit here is that if `PaymentService` uses the OAuth security scheme, creating a Project Connection means both services will share the same OAuth application (client ID and client secret), simplifying security configuration and ensuring consistent authentication for this shared service across the project.
|
docs\choreo-concepts\connections.md/Project Connections
|
Project Connections
|
I'm developing a Go microservice in Choreo that needs to connect to a very specific, on-premise legacy SOAP service. This legacy service is only relevant to this single Go microservice and won't be used by any other components in my Choreo project. What's the recommended connection type for this scenario?
|
For a scenario where a connection to a specific legacy SOAP service is exclusive to a single Go microservice and not intended for reuse by other components in your Choreo project, the recommended connection type is a 'Component Connection'. Component Connections are defined at the individual component level and are used solely by that component. You would create this connection for your Go microservice, and Choreo would provide a Connection ID and parameters (e.g., `LEGACY_SOAP_ENDPOINT`, `LEGACY_SOAP_API_KEY`). You'll map these parameters to environment variables within your Go microservice's configuration. Your Go application can then retrieve these values using `os.Getenv("LEGACY_SOAP_ENDPOINT")` to establish the programmatic connection to the legacy service.
|
docs\choreo-concepts\connections.md/Component Connections
|
Component Connections
|
My C# .NET component in Choreo needs to consume two different internal Choreo services, both secured with OAuth. Is there a way to streamline the OAuth setup so I don't have to manage separate client IDs and secrets for each connection within this single component?
|
Yes, if your C# .NET component consumes multiple Choreo services, and you define these integrations as 'Component Connections' under the OAuth security scheme, you can streamline the OAuth setup. The documentation states that Component Connections created to consume multiple Choreo services under the OAuth security scheme can share the same OAuth application by sharing the same client ID and client secret between all such connections. This means you can configure your component's connections to reuse the same OAuth credentials, simplifying management and ensuring consistent authentication for all internal Choreo services consumed by that specific C# .NET component.
|
docs\choreo-concepts\connections.md/Component Connections
|
Component Connections
|
Once I've configured a Choreo Connection and mapped its parameters to environment variables, how does my application code (e.g., a Java Spring Boot app or a Node.js service) actually retrieve these values at runtime to establish a connection?
|
At runtime, Choreo dynamically injects the values of the configured connection parameters into the environment variables you've mapped them to. Your application code can then simply read these environment variables using standard language-specific methods. For example:
* **Java Spring Boot:** You would use `System.getenv("YOUR_ENV_VAR_NAME")` or leverage Spring's `@Value("${YOUR_ENV_VAR_NAME}")` annotation.
* **Node.js:** You would access them via `process.env.YOUR_ENV_VAR_NAME`.
* **Python:** You would use `os.environ.get('YOUR_ENV_VAR_NAME')`.
* **Go:** You would use `os.Getenv("YOUR_ENV_VAR_NAME")`.
* **C# .NET:** You would use `Environment.GetEnvironmentVariable("YOUR_ENV_VAR_NAME")`.
This approach ensures that the connection parameter values and the service connection creation remain loosely coupled, providing developers with flexibility and ease of maintenance.
|
docs\choreo-concepts\connections.md/Connections
|
Connections
|
How do I decide if my organization needs a Choreo private data plane instead of a cloud data plane for deploying our applications, especially concerning data privacy and control?
|
You should consider a private data plane (PDP) if your organization requires dedicated infrastructure for running its user applications, ensuring an added layer of privacy and control. In contrast, a cloud data plane utilizes a multi-tenanted infrastructure model. The PDP ensures strict containment of user data within its boundaries, as all traffic related to the runtime of user applications is restricted to the Choreo data plane.
|
docs\choreo-concepts\data-planes.md/Data Planes
|
Data Planes
|
What are the essential infrastructure requirements I need to prepare if I want to set up a Choreo private data plane on my existing cloud provider, such as Azure, AWS, or GCP?
|
To set up a Choreo private data plane, you will need the following essential infrastructure components: an upstream-compatible Kubernetes cluster, a container registry, a key vault (secret store), and a logging service or log storage. These requirements apply whether you deploy on major cloud providers like Azure, AWS, GCP, or even on-premises infrastructure.
|
docs\choreo-concepts\data-planes.md/Private data planes
|
Private data planes
|
My organization has strict outbound network policies. Which specific endpoints and protocols do I need to whitelist for a Choreo private data plane to communicate effectively with the Choreo control plane and other external services?
|
All communications from the private data plane are outbound, meaning you don't need to open specific `IP:Port` for inbound traffic. However, if your network restricts all outbound traffic, you must permit outbound traffic to the public IP range of the Choreo control plane. Key outbound connections include:
- **Choreo PDP agent:** To Choreo control plane (mizzen server) via WSS, and to Kubernetes API server (cluster internal) via HTTPS, WS.
- **APIM/local adaptor:** To Global adaptor via HTTPS, and to Azure Service Bus (CP) via AMQP.
- **APIM/Enforcer:** To Event hub (CP) via AMQP.
- **Choreo secret resolver:** To Cloud secret store (VPC internal) via HTTPS.
- **Container registry:** To Container registry (VPC internal) via HTTPS.
- **Certificate manager:** To Azure DNS service via HTTPS, and to LetsEncrypt via HTTPS.
- **Flux source controller:** To GitHub via HTTPS.
- **Flux Helm controller:** To Choreo container registry via HTTPS.
All communication with the control plane is secured using TLS.
|
docs\choreo-concepts\data-planes.md/Connectivity with the control plane
|
Connectivity with the control plane
|
How does Choreo ensure that my sensitive application logs and observability data remain within my private data plane and are not transferred to the Choreo control plane or other external systems?
|
Choreo's private data plane observability architecture is designed to retain logs and observability data within the data plane itself. This is achieved by:
1. **Data storage at source:** Logs and observability data are stored directly within the data plane.
2. **Direct browser-to-data-plane interaction:** The Choreo Console in the user's browser directly interacts with APIs in the data plane to fetch this information, reducing potential data routing complexities.
3. **Reduced data exposure points:** Fetching data directly from the data plane's APIs minimizes the number of data transfer points.
This architecture supports data locality, aligning with regulatory standards like GDPR and CCPA, and ensures user transparency and control over data access.
|
docs\choreo-concepts\data-planes.md/Observability architecture
|
Observability architecture
|
What core software components are automatically installed and managed by Choreo when I deploy a private data plane using Helm on my Kubernetes infrastructure?
|
When you set up a Choreo private data plane using a Helm installation on your Kubernetes infrastructure, the following software components are automatically installed:
- Cilium CNI and service mesh.
- Choreo API Gateways and related components.
- Choreo PDP agent.
- Observability and logging APIs, along with observability agents.
- Flux controller.
These components receive automatic updates, including security patches and bug fixes, via the Flux controller connected to the Choreo Update Management System.
|
docs\choreo-concepts\data-planes.md/System components
|
System components
|
If I choose the 'Customer self-managed' model for my Choreo private data plane, what specific responsibilities does WSO2 handle, and what do I need to manage myself?
|
In the 'Customer self-managed' model for a Choreo private data plane, WSO2 provides the necessary installation script and handles updates for the Choreo PDP system components. This implies that while WSO2 ensures the core Choreo software within your PDP is up-to-date and functional, you, as the customer, are responsible for managing the underlying infrastructure (Kubernetes clusters, container registry, key vault, logging service) and its operations.
|
docs\choreo-concepts\data-planes.md/Management models
|
Management models
|
How does Choreo secure the network traffic for my applications deployed within a private data plane, particularly regarding inbound connections and internal data paths?
|
The Choreo private data plane provides extensive, production-grade security. All incoming traffic is protected by a firewall and must undergo authentication and authorization via the API Gateway. For internal data paths, it provides end-to-end network traffic encryption using Cilium transparent encryption, ensuring efficient data path encryption.
|
docs\choreo-concepts\data-planes.md/Security
|
Security
|
Can I deploy a mix of different application types and programming languages, such as a Java Spring Boot microservice, a Python FastAPI, and a React web application, all within the same Choreo data plane?
|
Yes, Choreo's data plane supports a polyglot approach. You can deploy applications ranging from services and web applications to APIs, integrations, and scheduled tasks, and these applications can be written in various programming languages. This means you can indeed deploy a mix of Java, Python, React, and other language-based applications within the same Choreo data plane.
|
docs\choreo-concepts\data-planes.md/Data Planes
|
Data Planes
|
How can I set up Choreo to automatically deploy my microservice whenever I merge a pull request to a specific branch in my GitHub repository?
|
To achieve automatic deployments, you need to link a Choreo Deployment Track to the specific branch within your GitHub repository. Once this connection is established and the automatic deployment functionality is activated, merging a pull request (PR) to that linked branch will automatically trigger a deployment of your microservice to the development environment.
|
docs\choreo-concepts\deployment-tracks.md/CI/CD with Deployment Tracks
|
CI/CD with Deployment Tracks
|
I have a pre-built Docker image for my Node.js application stored in a private container registry. How do I use Choreo's Deployment Tracks to deploy this image without integrating Choreo's CI system?
|
If you prefer to use your own Continuous Integration (CI) systems and only leverage Choreo for Continuous Deployment (CD), you can link a Choreo Deployment Track directly to your container registry repository. This configuration enables you to effortlessly deploy images sourced from that linked container registry, effectively using the deployment track as a CD-Only pipeline.
|
docs\choreo-concepts\deployment-tracks.md/CD-Only strategy with Deployment Tracks
|
CD-Only strategy with Deployment Tracks
|
My Choreo service component exposes an API, and I need to manage its versions. How does Choreo's API versioning mechanism work, especially when I introduce breaking changes or new backward-compatible features?
|
For service components, Choreo implements an API versioning mechanism based on Semantic Versioning (SemVer), specifically using a `v` prefix followed by the major and minor versions (e.g., `v1.2`). You should increment the major version (e.g., from `v1.x` to `v2.0`) when you introduce incompatible API changes. For new functionality that is added in a backward-compatible manner, you should increment the minor version (e.g., from `v1.1` to `v1.2`).
|
docs\choreo-concepts\deployment-tracks.md/Efficient API versioning
|
Efficient API versioning
|
When deploying a new version of my API service component in Choreo, how do I specify the API version (e.g., `v1.0`, `v1.1`) that consumers will see?
|
When working with deployment tracks for your API service component, you only need to specify the major and minor versions (e.g., `v1.0`, `v1.1`, `v2.0`). This information is treated as the 'API version attribute' of the deployment track itself. Choreo will then present this `vMajor.Minor` format to API consumers.
|
docs\choreo-concepts\deployment-tracks.md/Efficient API versioning
|
Efficient API versioning
|
Choreo's API versioning focuses on major and minor versions. If I need to track patch updates or other internal versions for my API service component, how can I do that?
|
While Choreo's API versioning for consumers focuses on major and minor versions, you can use external tools for internal tracking of patch updates or other granular versions. Publishers can accomplish this through standard Git practices, such as using Git tags, or by leveraging features like GitHub releases.
|
docs\choreo-concepts\deployment-tracks.md/Efficient API versioning
|
Efficient API versioning
|
I've deployed a simple Python Flask microservice to Choreo without providing an OpenAPI specification. How will Choreo expose its endpoints by default?
|
If you don't provide a service contract like OpenAPI or GraphQL SDL for your Python Flask microservice, Choreo will use `/*` exposed on all HTTP verbs as the default contract to expose your service's endpoints.
|
docs\choreo-concepts\endpoint.md/Endpoint
|
Endpoint
|
I have a Java Spring Boot microservice deployed on Choreo, and I want to apply specific authentication policies to only the `/admin` endpoint, while leaving other endpoints like `/public` accessible without authentication. Is this level of granular control possible?
|
Yes, Choreo allows for granular API management per endpoint. Each endpoint exposed in your Spring Boot microservice is considered a single API. This means you can perform lifecycle management and configure security settings, such as specific authentication policies, individually for your `/admin` endpoint without affecting other endpoints within the same component.
|
docs\choreo-concepts\endpoint.md/API Management per Endpoint
|
API Management per Endpoint
|
I'm developing a GraphQL API using Apollo Server in Node.js and want to ensure Choreo properly understands and exposes its schema. How do I associate my GraphQL SDL with the endpoint in Choreo?
|
To ensure Choreo properly understands and exposes your GraphQL API, you should associate your GraphQL SDL (Schema Definition Language) as the service contract for your endpoint. Choreo supports both OpenAPI and GraphQL SDL for defining service contracts, which are then used to expose the endpoint to consumers.
|
docs\choreo-concepts\endpoint.md/Endpoint
|
Endpoint
|
I've deployed a Go microservice to Choreo and now I need to configure its exposed endpoints, specifically associating an OpenAPI definition with them. Where in the Choreo platform can I find the settings to do this?
|
To configure the endpoints of your Go microservice, including associating an OpenAPI definition, you would typically do this during the development and configuration phase within Choreo. The documentation points to the 'Configure Endpoints' section for detailed instructions on how to manage these settings when developing components in Choreo.
|
docs\choreo-concepts\endpoint.md/Configure Endpoints
|
Configure Endpoints
|
I've developed my Node.js API in the `development` environment; how do I move it to `production` in Choreo, ensuring it uses production-specific database credentials?
|
In Choreo, you can promote components, such as your Node.js API, from one environment (like `development`) to another (like `production`). During this promotion process, you have the ability to override the component's configuration values with environment-specific settings. This means you can specify your production-specific database credentials to be applied when the API is deployed to the `production` environment.
|
docs\choreo-concepts\environments.md/Environments
|
Environments
|
My team needs a `staging` environment for our Java Spring Boot microservice in Choreo, in addition to `development` and `production`. Is this possible, and how do I configure my project to use it?
|
Yes, it is possible for your project to utilize a `staging` environment in addition to `development` and `production`. Choreo allows each project to be associated with one or more environments available in the organization. For instance, a project can be configured to use `dev`, `staging`, and `production` environments. While the document doesn't detail the exact configuration steps, it confirms the capability for projects to choose and utilize multiple environments beyond the default two.
|
docs\choreo-concepts\environments.md/Environments
|
Environments
|
When I start a new project for my Python FastAPI application in Choreo, what environments are available by default, and how does my project get associated with them?
|
By default, the Choreo cloud data plane provides two environments: `development` and `production`. When you create a new project for your Python FastAPI application, it will be associated with one or more of the environments available in your organization. This means your project can immediately begin utilizing these default environments for different stages of your application's lifecycle.
|
docs\choreo-concepts\environments.md/Environments
|
Environments
|
How can I configure environment-specific variables, like an external API key, for my Docker container deployed on Choreo when promoting it from `development` to `production`?
|
When you promote your Docker container component from the `development` environment to the `production` environment in Choreo, you are able to override its configuration values. This mechanism allows you to specify different values for environment-specific variables, such as an external API key, ensuring that the correct key is used for each respective environment.
|
docs\choreo-concepts\environments.md/Environments
|
Environments
|
As a first-time user, what's the initial step to get started with Choreo and set up my workspace, and can I create multiple workspaces for different projects?
|
When you sign in to Choreo for the first time, you must create an organization. This organization serves as a logical grouping for your users and resources. You cannot create more than one organization yourself, but you can be a member of multiple organizations if invited by an admin of another organization.
|
docs\choreo-concepts\organization.md/Organization
|
Organization
|
I'm a consultant working with multiple clients, each with their own Choreo organization. How can I quickly switch between their environments in the Choreo Console to manage their respective resources?
|
If you are a member of more than one organization, you can easily switch between them. To do this, sign in to the Choreo Console, then select the required organization from the **Organization** list located in the header.
|
docs\choreo-concepts\organization.md/Switch organizations
|
Switch organizations
|
I need to onboard a new team member who will be responsible for creating, publishing, and managing new APIs in Choreo. Which predefined group should I add them to to ensure they have the necessary permissions?
|
To grant a new team member permissions for creating, publishing, deleting, testing, and managing APIs, you should add them to the `API Publisher` group. This group is pre-configured to assign the `API Publisher` role, which provides all these capabilities.
|
docs\choreo-concepts\organization.md/Groups
|
Groups
|
Our finance department needs access to manage billing, view tiers, and handle invoices for our Choreo usage. What specific role or group should I assign to their user accounts?
|
For users who need to handle billing administration, including viewing tiers, managing organizations and invoices, and managing subscriptions and payment methods, you should assign them the `Billing Admin` role. Alternatively, you can add them to the `Billing Admin` group, which automatically grants this role.
|
docs\choreo-concepts\organization.md/Roles
|
Roles
|
I'm setting up a CI/CD pipeline for my Go microservice and need a team member to manage its deployment, monitoring, and reliability within Choreo. Which role should I assign them, considering the recent changes in roles?
|
For managing deployment, monitoring, and reliability of components in Choreo, the recommended role is `Choreo Platform Engineer`. While the `Choreo DevOps` role previously served this purpose, it has been replaced. However, if your organization previously used the `Choreo DevOps` role, it will still be visible and functional for existing assignments.
|
docs\choreo-concepts\organization.md/Roles
|
Roles
|
My external partner needs to consume APIs from our Choreo organization but should not have access to internal development resources or the ability to publish new APIs. What's the appropriate role for them?
|
For an external partner who only needs to consume APIs with Developer Portal access and join an organization exclusively for API usage, you should assign them the `External API Subscriber` role. This role is specifically designed for such scenarios.
|
docs\choreo-concepts\organization.md/Roles
|
Roles
|
I'm developing an integration that requires my Choreo organization's unique identifier. How do I locate and copy my Organization ID from the Choreo Console?
|
To get your Organization ID, follow these steps:
1. Go to [https://console.choreo.dev/](https://console.choreo.dev/) and sign in.
2. Click on the **Organization** list in the header and select your organization.
3. In the left navigation, click **Settings**.
4. In the header, click the **Organization** list again. This will open the organization level settings page.
5. Under **Organization**, click **Copy ID**.
|
docs\choreo-concepts\organization.md/Organization ID
|
Organization ID
|
For a custom script or external configuration, I need the unique string handle that directly corresponds to my Choreo organization's name. Where can I find this 'Organization Handle'?
|
To get your Organization Handle, follow these steps:
1. Go to [https://console.choreo.dev/](https://console.choreo.dev/) and sign in.
2. Click on the **Organization** list in the header and select your organization.
3. In the left navigation, click **Settings**.
4. Under **Organization**, click **Copy Handle**.
|
docs\choreo-concepts\organization.md/Organization Handle
|
Organization Handle
|
What are the comprehensive administrative capabilities of a user assigned the 'Admin' role in Choreo? Can they manage more than just users?
|
Yes, a user with the `Admin` role in Choreo can perform a wide range of administrative tasks beyond just user management. This includes Developer Portal customization, project management, analytics configuration, and domain management, in addition to all user-related administrative functions.
|
docs\choreo-concepts\organization.md/Roles
|
Roles
|
I have a monorepo containing a Node.js API and a Python data processing service. How can I deploy both as part of the same application in Choreo, ensuring they share resources efficiently?
|
Choreo projects are designed to support monorepo architectures. You can include multiple components from different paths within a single GitHub repository into one Choreo project. At deployment time, all these components will be deployed into a single Kubernetes namespace, allowing them to function as a cohesive application and potentially share resources within that namespace.
|
docs\choreo-concepts\project.md/Project
|
Project
|
I'm deploying a Java Spring Boot API and a GoLang background worker in Choreo. How do I configure the GoLang worker to only be accessible by my Spring Boot API within the same project, preventing public exposure?
|
When defining components within your Choreo project, you can configure their exposure level. For your GoLang background worker, you would set its exposure to 'privately within the project only'. This ensures that the worker can communicate with other components like your Java Spring Boot API within the same project's Kubernetes namespace, but it will not be accessible from the public internet or other parts of your organization.
|
docs\choreo-concepts\project.md/Project
|
Project
|
I have a public-facing React frontend and a separate internal administrative API (e.g., built with .NET Core) that both belong to the same application. How can I deploy them in Choreo so the frontend is public and the admin API is only accessible within my organization?
|
Within a single Choreo project, you can define multiple components and set their individual exposure levels. For your React frontend, you would configure it to be 'exposed to the public internet'. For your .NET Core administrative API, you would set its exposure to 'internally to the rest of the organization'. Both components will reside within the same Kubernetes namespace as part of the project, but their network accessibility will differ based on your configuration.
|
docs\choreo-concepts\project.md/Project
|
Project
|
If I deploy multiple microservices, like a Python Flask API and a separate Node.js authentication service, within a single Choreo project, will they share the same Kubernetes namespace, and what are the implications for network communication?
|
Yes, if you deploy multiple components such as a Python Flask API and a Node.js authentication service within a single Choreo project, they will all be deployed into a single namespace of the Kubernetes cluster. This means they will share the same network space within that namespace, simplifying internal communication between them as they can typically discover and communicate with each other directly without needing external routing.
|
docs\choreo-concepts\project.md/Project
|
Project
|
I'm designing my application based on the Cell-based architecture principles. How does a Choreo 'Project' align with the concept of a 'Cell' in this architecture?
|
In Choreo, a 'Project' is directly represented as a 'cell' with regard to the Cell-based architecture. This means that a Choreo project encapsulates a logical group of related components (like a single cloud-native application) and provides the necessary isolation and boundaries, consistent with the principles of a cell as defined in the Cell-based architecture.
|
docs\choreo-concepts\project.md/Project
|
Project
|
How do I deploy my new Node.js microservice to a specific development environment within my Choreo project?
|
Components belong to a project in Choreo, and environments are provisioned per project. To deploy your Node.js microservice, you would deploy it as a container to the specified `development` environment that you have set up within your project.
|
docs\choreo-concepts\resource-hierarchy.md/Components and environments
|
Components and environments
|
My critical Java Spring Boot application needs to be highly resilient. How can I configure my Choreo `production` environment to utilize multiple Kubernetes clusters for high availability and resource efficiency?
|
Choreo allows multiple Kubernetes clusters to be associated with a single environment. For your `production` environment, you can associate multiple clusters, and Choreo will synchronize your application and workloads between these associated clusters. This enables you to perform multi-cluster deployment with a single click, achieving high resilience and resource-efficient solutions.
|
docs\choreo-concepts\resource-hierarchy.md/Environments and data planes
|
Environments and data planes
|
After successfully testing my Python FastAPI service in the `staging` environment, what is the recommended process to promote the *exact same container image* to my `production` environment in Choreo?
|
Once your Python FastAPI service (component) is deployed as a container to the `staging` environment, you can promote that same container image across other environments available in your project, such as your `production` environment. This ensures consistency by using the identical build that was validated in `staging`.
|
docs\choreo-concepts\resource-hierarchy.md/Components and environments
|
Components and environments
|
When I create a new `development` environment for my project in Choreo, how does Choreo manage the underlying Kubernetes infrastructure, specifically regarding namespaces and data planes?
|
When you create an environment (e.g., `development`) in a project, the data plane that is connected to your organization is automatically linked with an automatically generated Kubernetes namespace. This means your `development` environment will operate within its own dedicated Kubernetes namespace, which is part of the organization's shared data plane.
|
docs\choreo-concepts\resource-hierarchy.md/Organizations and data planes
|
Organizations and data planes
|
Can I host multiple environments, such as `development` and `staging`, for my React frontend and its Go backend API on the *same* underlying Kubernetes cluster in Choreo, or do I need a separate cluster for each environment?
|
No, it is not necessary to use a different Kubernetes cluster per environment. You can indeed create multiple environments, such as `development` and `staging`, on the same cluster within Choreo. While Choreo allows associating multiple clusters with an environment, it also supports configurations where multiple environments share a single cluster.
|
docs\choreo-concepts\resource-hierarchy.md/Environments and data planes
|
Environments and data planes
|
No dataset card yet
- Downloads last month
- 7