Dataset Viewer
system_prompt
null | user_prompt
stringlengths 107
306
| assistant_response
stringlengths 66
805
| ground_truth
stringlengths 210
1.01k
|
|---|---|---|---|
null | 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? | If you know the name of the API (e.g., "Order Processing") or a keyword from its description (e.g., "order processing"), you can use the 'search' feature in the marketplace to locate it. | 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. |
null | 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? | To filter and see only internal services, you can use the 'All' option in the 'Service' tab of the Marketplace. | 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. |
null | 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 ensure that your `CustomerData` service is only visible within the specified project within the Marketplace, you must grant the necessary permissions to this project. This can be done through the 'Manage' tab of the `CustomerData` service page and selecting 'Permissions'. | 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. |
null | 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? | To view the API contract of a specific `PaymentGatewayService`, you can use the `get_api_contract` endpoint provided by the service. This endpoint returns the API contract as an object containing all the required information for integration with that particular `PaymentGatewayService`. | 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. |
null | 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? | To connect to the `NotificationService`, you need to create an HTTP client connection to the `NotificationService`. This is done through the `client.get_notification_service()` method within the `NotificationService` class. To consume this service, you should make a GET request to the endpoint specified in the `client.get_notification_service()` call. | 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. |
null | 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 ensure that the 'Overview' section on your `InventoryManagement` service's Marketplace entry is populated with useful information for other developers, you can update it to include relevant details such as the version of the service, any recent updates, and the latest supported versions. Additionally, if you have any documentation or API reference available, you can share them here. | 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. |
null | 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? | Yes, you will need to deploy the `UserAuthentication` component to the initial environment of your project and then publish it to the Choreo Marketplace using the `choreo user authentication` command within the project's directory structure. | 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. |
null | 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? | No, your `OrderProcessing` service must still use `v1` at all times, even if `v1.3` becomes available. This means you cannot simply switch to `v1.3` and assume it's already up-to-date. | 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`. |
null | 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? | The `v1` entry in the Marketplace represents the latest version of the `ProductCatalog` service, while the `v2` entry represents the previous (older) version. | 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). |
null | 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? | If you haven't already done so, you should manually update the `UserManagement` service's entry in the Choreo Marketplace. However, this action will not automatically trigger a deployment of the component within the marketplace. | 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. |
null | 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? | The initial step is to deploy your service using the 'Deploy' action in Choreo. This will automatically create an empty Docker container image and push it to the 'production' repository within Choreo. To ensure that you have the latest version of this image, you should also deploy the 'latest' action to 'production'. This ensures that all changes made during the 'deploy' action are immediately reflected in the 'production' repository. | 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. |
null | 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 configuration in Choreo, you can create separate service configurations within each environment directory. | 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. |
null | 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 create a fully automated CI/CD pipeline for your Node.js API using Choreo, follow these steps:
1. In the 'Continuous Integration' section of the 'Project Settings', click on 'New CI/CD Pipeline'. This will open the 'Create CI/CD Pipeline' page.
2. Select 'Node.js API' from the dropdown menu under 'Service'. This will create a new CI/CD pipeline specifically for your API service.
3. Choose 'Deploy' as the action type, which ensures that whenever you make a pull request (PR), the code is deployed automatically to the corresponding branch of your repository.
4. Click 'Create' to generate a unique name for the newly created CI/CD pipeline.
5. Navigate to the 'CI/CD' tab within the project settings to manage all aspects of your CI/CD pipeline, including build, test, and deployment configurations. | 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. |
null | 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? | To securely inject the external API key into your service, you can use the `env` environment variable in Choreo. This ensures that the API key is only accessible within the specified environment (e.g., production). | 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. |
null | 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? | To ensure that your Go microservice is promoted to the production environment, you need to follow these steps:
1. Navigate to 'Settings' and then select 'Continuous Deployment'.
2. In the 'Continuous Deployment' section, click on 'Build' next to 'Production'. This will create a new deployment branch named 'production'. | 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. |
null | My recent build for my Dockerfile-based component failed. How can I check the build logs to understand why it failed? | You can view the build logs from your DockerHub account using the following command: docker logs <container-name>. | 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. |
null | 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? | To ensure that Choreo builds and deploys the specified version again, you must manually build and deploy the old version using the `choreo-deploy` command. This ensures that your application is up-to-date with the most recent code changes. | 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. |
null | 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 that your user won't experience any downtime during the deployment of a new version of your 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. |
null | 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? | To ensure that your custom Dockerfile is used when building the container image with Choreo, you can add the following line to your Dockerfile:
```yaml
FROM quay.io/your-project/my-rust-app:latest
```
This instructs Choreo to use your custom Dockerfile instead of automatically 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. |
null | Can I integrate my unit tests for my Java application directly into Choreo's build pipeline, and if so, how? | Yes, you can directly integrate your unit tests in the Choreo build pipeline. | 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. |
null | 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 the microservice as a component in Choreo, you need to ensure that it is deployed in a single directory. This can be done using the `deploy` step of the `choreo-deploy` command. | 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. |
null | 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? | To ensure Choreo deploys your component using the specified Dockerfile, you must create a service with the `--dockerfile` flag set to your custom Dockerfile. | 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. |
null | 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? | To scale the API independently, you need to add it to an existing service and enable automatic scaling for it. This will automatically increase its capacity based on the demand of incoming requests. | 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. |
null | 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 this use case, you would need to utilize the Data Sync component in Choreo. To ensure that your job runs every day at a specified time, you can create a cron job within the same application instance. | 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. |
null | 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? | A single-page application (SPA) can be hosted using the Choreo component type, which facilitates seamless integration with the user interface and integrates seamlessly with the RESTful API provided by the backend. | 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. |
null | 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? | Each Choreo component corresponds to a single Kubernetes pod, ensuring maximum scalability and flexibility. | 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. |
null | 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 microservice to the external PostgreSQL database, you need to ensure that the service has the necessary permissions and configurations. This can be achieved using Docker Compose or any other containerization method. | 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. |
null | 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? | To ensure that your Python FastAPI application can seamlessly utilize Twilio services across multiple projects without duplicating code, you should consider setting up a single instance of `Twilio` globally. This approach simplifies maintenance and reduces redundancy. | 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. |
null | 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 ensure secure communication between `OrderService` and `PaymentService`, you can utilize `HttpMessageConverter` for HTTP request headers and `WebSocket` for WebSocket connections. Additionally, you may want to consider implementing a service registry or a service gateway layer that provides a unified API for both services. | 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. |
null | 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 scenarios like these, the recommended connection type is `REST`. | 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. |
null | 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, you can achieve this by leveraging the `OAuth Client ID` feature provided by Choreo. This allows you to share a single client ID across all your OAuth connections without needing separate client IDs for each service. | 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. |
null | 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? | Your application code retrieves the required values from the environment variables at runtime using `System.getenv()` method. | 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. |
null | 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? | When deciding between a cloud or a private data plane, it is important to consider the specific requirements of your organization's applications and data. If you need strict adherence to data privacy standards, then a cloud data plane may be more appropriate. However, if you require greater flexibility in terms of data controls, such as encryption or access management, then a private data plane might be a better choice. | 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. |
null | 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? | If you want to deploy a Choreo instance in your existing cloud provider (Azure, AWS, or GCP), you will need to ensure that your chosen cloud provider supports the deployment of Choreo instances directly from within their own platform. This means that you will not need any additional infrastructure; all necessary components and configurations are already included with your chosen cloud provider. | 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. |
null | 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? | To ensure that your Choreo private data plane can communicate effectively with the Choreo control plane and other external services, you must whitelist specific endpoints and protocols on both the Choreo control plane's inbound and outbound networks. | 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. |
null | 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 ensures that all data generated during development is stored in a secure manner within its own containerized environment. This prevents any potential security risks associated with exposing sensitive data outside of its controlled environment. | 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. |
null | 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 deploy a private data plane using Helm on your Kubernetes infrastructure, the default component that is automatically installed and managed by Choreo is 'kubeconfig'. This component ensures that all necessary configurations for the private data plane are in place before any deployment begins. | 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. |
null | 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 this case, you will be responsible for managing the entire lifecycle of all data flows within your Choreo environment. This includes creating, managing, and deleting data flows at any point in time, as well as setting up security policies, API gateways, and service mesh configurations. | 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. |
null | How does Choreo secure the network traffic for my applications deployed within a private data plane, particularly regarding inbound connections and internal data paths? | Choreo uses HTTPS encryption to ensure that only encrypted data is transmitted between your applications and the cloud environment. It also restricts direct access from external networks to specific APIs or services within the application. | 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. |
null | 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, you can deploy multiple application types on a single data plane in Choreo. | 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. |
null | 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 ensure that your microservice is deployed automatically whenever you merge a pull request to the specified branch in your GitHub repository, you need to configure Choreo to automatically trigger a deployment of the microservice every time a new commit is made to that branch. | 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. |
null | 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? | To deploy the pre-built Docker image using Choreo's Deployment Tracks, you need to create a new deployment track and then trigger an auto-scaling deployment with that track. | 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. |
null | 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? | When introducing breaking changes or new backward-compatible features, Choreo automatically creates two separate API versions: the original one with all features, and a new one that only includes those features in which there is no backwards compatibility issue (e.g., for APIs that expose internal state). This ensures that users can continue using their old API while maintaining backwards compatibility. | 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`). |
null | 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? | To ensure consumers see the latest and most recent versions of your API component, you should set both the `version` and `api-version` parameters to `latest`. | 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. |
null | 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? | For your API component, you can use the `@choreo/api-version` package provided by Choreo. | 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. |
null | I've deployed a simple Python Flask microservice to Choreo without providing an OpenAPI specification. How will Choreo expose its endpoints by default? | By default, Choreo exposes all the API endpoints provided in the project's 'api.yaml' file. | 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. |
null | 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, it is possible. To achieve this, you can use an `OAuth2` configuration in your `application.properties` file. | 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. |
null | 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 associate your GraphQL SDL with the endpoint in Choreo, you need to provide an `@graph` reference that points to your GraphQL SDL's path. | 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. |
null | 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 exposed endpoints for a Go microservice within Choreo, you should navigate to the 'Settings' section of the project dashboard. Here, under 'Endpoints', you will find various options related to endpoint configurations. | 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. |
null | 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? | To move your API from development to production in Choreo, you need to ensure that the API is set up with the correct database credentials and environment variables for production. | 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. |
null | 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, you can set up a `staging` environment within your `development` and `production` environments using the `Staging` service. This will allow you to easily transition from production to development or vice versa. | 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. |
null | 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, your project is associated with the 'dev' environment. | 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. |
null | 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`? | To deploy the current version of your application to production, you can use a deployment manifest file named `docker-compose.yml`. This file contains configuration details, including the `environment`, which includes both `development` and `production` configurations. To ensure that the specified environment is used in production, you should include an entry for `production` in this configuration file. | 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. |
null | 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? | To get started, you need to log in to your local machine via SSH. Next, navigate to the 'Workspaces' section within the 'System' menu. Here, you'll find a 'Create Workspace' option, which allows you to create an existing workspace or start from scratch. | 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. |
null | 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? | To quickly switch between their environments in the Choreo Console, you can use the 'Switch Environment' button under the 'Manage' menu. This will automatically switch to the environment of the selected client and display the available resources within that environment. | 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. |
null | 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 ensure that the new team member has the necessary permissions, you can add them to the 'API Developer' group. | 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. |
null | 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? | The finance team can be assigned the role of 'Billing Administrator' within Choreo, allowing them to manage billing, view tiers, and handle invoices. | 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. |
null | 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? | Since the recent changes in roles, you should assign a 'Developer' role to the individual responsible for managing your Go microservice's deployment, monitoring, and reliability within Choreo. | 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. |
null | 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? | The appropriate role for your external partner is an 'API consumer'. | 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. |
null | 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 find your Organization ID in the Choreo Console, click on the 'Organization' tab. Then, navigate to the 'Details' section within the organization. From there, you can see the `Organization ID` for your organization. | 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**. |
null | 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 find the 'Organization Handle', navigate to the 'Settings' page of your organization in the Choreo UI. | 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**. |
null | What are the comprehensive administrative capabilities of a user assigned the 'Admin' role in Choreo? Can they manage more than just users? | A user with the 'Admin' role can manage more than just users. They can also manage services, environments, and clusters. | 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. |
null | 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? | To deploy both the Node.js API and the Python service within the same application, you should ensure that each component is deployed separately using separate Docker images or containers. | 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. |
null | 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? | To ensure that your GoLang worker is accessible solely from your Spring Boot API within the same project, you must expose it as a service within the same Docker container. This allows for secure isolation between the two applications. | 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. |
null | 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? | To deploy your public-facing React frontend and your internal administrative API separately, you need to create two distinct environments in Choreo: one for the frontend and another for the administrative API. | 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. |
null | 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 both microservices within the same Choreo project, they will share the same Kubernetes namespace. However, this shared namespace can cause conflicts in terms of network communication between services. | 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. |
null | 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? | A 'Project' is aligned to the 'Cell' principle as it represents a single component within a larger cell. | 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. |
null | How do I deploy my new Node.js microservice to a specific development environment within my Choreo project? | To deploy your new Node.js microservice to a specific development environment within your Choreo project, you can use the 'Deploy' feature provided by Choreo. | 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. |
null | 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? | To achieve this, you need to enable the `multi-cluster deployment` feature in your `production` environment. This will ensure that your application is deployed on multiple Kubernetes clusters simultaneously. | 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. |
null | 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? | To ensure that your `production` environment mirrors the exact same container image as your `staging` environment, you should use the same Dockerfile across both environments. | 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`. |
null | 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? | Choreo manages the entire Kubernetes infrastructure, including the namespace and data plane. This ensures that all components within this namespace are interconnected seamlessly across different environments. | 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. |
null | 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? | Yes, you can host multiple environments, such as `development` and `staging`, for your React frontend and its Go backend API on the same underlying Kubernetes cluster in Choreo. | 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. |
README.md exists but content is empty.
- Downloads last month
- 0