Unnamed: 0
int64 0
71
| user_input
stringlengths 107
306
| response
stringlengths 61
1.08k
| reference
stringlengths 210
1.01k
| bleu_score
float64 0.02
0.43
| rouge_score(mode=fmeasure)
float64 0.08
0.43
|
|---|---|---|---|---|---|
0
|
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 locate a specific API in the Choreo Marketplace, you can search for it using keywords associated with that API. For example, if you're searching for 'order processing', you would use 'order processing' as your query.
|
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.
| 0.190943
| 0.297872
|
1
|
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 the Marketplace to show only the services your team has deployed internally, you can use the 'All' selection in the search bar on the left side of the page.
|
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.
| 0.091884
| 0.238806
|
2
|
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 check the visibility of your CustomerData service within the Marketplace, you need to open the 'API Explorer' and click on 'Public'. This will display all API versions available for public access.
|
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.
| 0.097872
| 0.321839
|
3
|
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 `PaymentGatewayService`, you can visit the corresponding component page within the Marketplace. This will provide detailed information about the service's APIs, including their endpoints and data models.
|
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.
| 0.094122
| 0.204545
|
4
|
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 must create an instance of the `NotificationService` class from the `Notifications` module within your Python FastAPI application. This will provide you with access to all relevant API endpoints for subscribing and consuming notifications.
|
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.
| 0.125852
| 0.153846
|
5
|
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 of your `InventoryManagement` service in the Marketplace, you need to upload a relevant documentation document. To add additional related documents, you should create one or more documentation 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.
| 0.254783
| 0.3125
|
6
|
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 manually deploy your new `UserAuthentication` service component in the Choreo Marketplace and make it discoverable there.
|
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.
| 0.0794
| 0.264706
|
7
|
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 will not be updated with `v1.3`, but it will continue to use `v1` until an update of `v1` is made by the `ShippingAPI` team.
|
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`.
| 0.237462
| 0.159091
|
8
|
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 initial version of the service, while the `v2` entry indicates the latest stable release available at the time of deployment.
|
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).
| 0.27933
| 0.365854
|
9
|
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?
|
Both descriptions and network visibility settings will be automatically applied to the `UserManagement` component on the Choreo Marketplace. No manual updates are required.
|
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.
| 0.10079
| 0.137931
|
10
|
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 deployment step you need to take is to deploy your service to the development environment using Choreo's `dev` branch. You can automate this build process by setting up an automated pipeline that runs on a weekly schedule.
|
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.
| 0.122591
| 0.235294
|
11
|
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 the necessary configuration settings for development and production environments in Choreo, you can create separate service components with distinct set of properties and configurations.
|
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.
| 0.057172
| 0.168421
|
12
|
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 with your Node.js API in Choreo, you can follow the steps below:
1. In the 'Build' tab of your project, click on 'Add Build Step'.
2. From the dropdown menu, select 'Continuous Integration' (CI).
3. Click 'Next', then 'Next', and finally 'Finish' to proceed.
This will open the 'Create CI/CD Pipeline' page. On this page, configure all necessary components such as 'Pipeline Name', 'Pipeline URL', and 'Environment'. Additionally, specify which environment you want to use (e.g., `production` or `staging`). Lastly, enable 'Automate Deployments' to ensure automatic deployment when a new version is built.
|
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.
| 0.412297
| 0.26738
|
13
|
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 store and inject the external API key from your external API in your Choreo-deployed service, you should use environment variables. This ensures that any changes made to the environment variable will be reflected immediately on deployment.
|
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.
| 0.075757
| 0.20339
|
14
|
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 deploy a specific build from the development environment to the production environment in Choreo, you need to create a deployment that includes both the development and production versions of your Go microservice. This can be achieved through the 'Deploy' feature within 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.
| 0.083459
| 0.213592
|
15
|
My recent build for my Dockerfile-based component failed. How can I check the build logs to understand why it failed?
|
To see the build logs, you can use the `docker logs` command in your terminal after building the Docker image using the provided Dockerfile.
|
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.
| 0.099415
| 0.243243
|
16
|
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 the correct version is deployed, you must use the same Git commit as your initial deployment.
|
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.
| 0.066426
| 0.153846
|
17
|
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 the new version of the backend API is deployed and available in parallel with the current one. This allows for seamless transitions between versions without any downtime or disruption to your users.
|
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.
| 0.187849
| 0.294737
|
18
|
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 Choreo builds the container image using your custom Dockerfile, you need to create a `.dockerignore` file in the root directory of your project and add only the necessary files or directories listed in it.
|
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.
| 0.042783
| 0.236559
|
19
|
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 within the Choreo build pipeline. This approach allows for a seamless integration of your development environment with the production environment.
|
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.
| 0.133535
| 0.247191
|
20
|
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 microservice as a component in Choreo, you need to clone the entire Git repository from GitHub. This will include all the files and directories within the project directory. Then, navigate into that directory and run `python manage.py create_component`.
|
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.
| 0.428495
| 0.3125
|
21
|
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 that Choreo uses your custom Dockerfile for building and deploying your component, you need to specify the necessary environment variables for this.
|
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.
| 0.101262
| 0.246154
|
22
|
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 ensure your API scales independently and handles high loads, you should create an independent service for that specific API.
|
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.
| 0.047249
| 0.151515
|
23
|
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 setting up a daily data synchronization job, you can use the `Job` component in Choreo. To schedule this job, you need to create a cron job that triggers every day at a specified time (e.g., 2:00 AM).
|
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.
| 0.337013
| 0.43038
|
24
|
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?
|
The Choreo Single-Page Application (SPA) component type is the `Application` component, which is designed to be hosted on your backend API. This component allows you to seamlessly integrate your frontend application into the existing infrastructure of your organization.
|
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.
| 0.041573
| 0.18
|
25
|
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 is mapped to one Kubernetes pod. This ensures seamless deployment and isolation between components.
|
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.
| 0.0315
| 0.298507
|
26
|
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 securely connect your Node.js microservice to the external PostgreSQL database hosted on AWS RDS, you can utilize the `connect` method provided by the `pg` library. This approach allows for seamless communication between your microservice and the external PostgreSQL database.
|
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.
| 0.350985
| 0.228261
|
27
|
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 project-wide reuse, you can configure a single `@app.on_startup` function that calls `TwilioRestClient.send_sms` with the necessary parameters, such as your API token and the message body. This approach ensures seamless communication across all components of the application.
|
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.
| 0.016349
| 0.139785
|
28
|
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 configure `SecurityContexts` in Choreo to authenticate the service components. This allows both services to exchange their security contexts for mutual authentication.
|
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.
| 0.111338
| 0.153846
|
29
|
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 this scenario, you should use `REST` as your connection type.
|
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.
| 0.073526
| 0.076923
|
30
|
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 use an OAuth2 Client ID/Secret pair to share one set of credentials across multiple components in Choreo. This allows you to maintain a single client ID/secret while ensuring that each component has its own unique client secret.
|
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.
| 0.056815
| 0.171429
|
31
|
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, the application code retrieves the values from the environment variable specified in the Choreo Connection's parameters.
|
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.
| 0.122993
| 0.135135
|
32
|
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?
|
To decide whether your organization should deploy its applications on the Choreo private data plane or the cloud, you can assess the following criteria: 1) Data privacy requirements; 2) Control over application components; 3) Security posture.
|
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.
| 0.055982
| 0.174757
|
33
|
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 on your existing cloud provider, you will need an adequate amount of computing resources.
|
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.
| 0.416577
| 0.311688
|
34
|
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?
|
For communication with the Choreo control plane, you should whitelist all endpoints on the Choreo control plane's public network (e.g., `http://10.255.0.1:8443`), as well as any endpoint within the same subnet that is accessible via HTTPS (`https://10.255.0.1`). For communication with the Choreo service itself, you should whitelist all endpoints on the Choreo service's public network (e.g., `http://10.255.0.1:9000`), including those reachable via HTTPS (`https://10.255.0.1`).
|
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.
| 0.087049
| 0.160338
|
35
|
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 logs and observability data are encrypted and stored on your private data plane. This prevents any unauthorized access or interception of your sensitive data.
|
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.
| 0.281718
| 0.167832
|
36
|
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, the default core software components that are automatically installed and managed by Choreo include `kubectl`, `helm`, `etcd`, `kube-apiserver`, `kube-scheduler`, `kube-proxy`, `kubernetes`, and `docker`.
|
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.
| 0.051939
| 0.342857
|
37
|
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?
|
For a 'Customer self-managed' model, WSO2 handles both API management and component management. You must ensure that your components comply with WSO2's requirements, including security policies, compliance with various standards (such as OAuth 2.0), and adhering to WSO2's own guidelines.
|
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.
| 0.059069
| 0.196429
|
38
|
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 securely routes requests to your applications from the cloud. The application's internal data paths remain unaffected; they're only exposed through API Gateway and Docker Registry.
|
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.
| 0.0499
| 0.155844
|
39
|
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 each type of application in its respective container using a single Docker image.
|
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.
| 0.053693
| 0.186667
|
40
|
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 set up Choreo to automatically deploy your microservice whenever you push a new commit to the specified branch on GitHub, follow these steps:
1. Go to the "Settings" page.
2. Under "Deployment", click "Create a deployment."
3. Click "Next".
4. In the "From" section, select "GitHub". Then, click "Next".
5. In the "Environment name" section, enter the desired environment name (e.g., "dev").
6. In the "Repository URL" section, paste the URL of the GitHub repository where your microservice is hosted.
7. In the "Repository URL" section, paste the URL of the repository where your microservice is hosted.
8. Click "Next".
9. In the "Build configuration" section, select "Automated deployment".
10. Click "Finish".
This will create an automatic deployment pipeline that deploys your microservice whenever a new commit is pushed to the specified branch in the 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.
| 0.052705
| 0.208333
|
41
|
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 use the Deployment Tracks feature of Choreo, you must first create a new deployment track using the 'Create Deployment Track' button on the 'Build and Deploy' page. This will automatically include all images from your pre-built Docker image repository in your chosen deployment tracks.
|
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.
| 0.053007
| 0.235294
|
42
|
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 in Choreo, you can use the `version` parameter on your API endpoint to specify the current version of the API.
|
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`).
| 0.037211
| 0.192308
|
43
|
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 that consumers can easily identify the specific version of your API service component they should use, you must explicitly configure the `api-version` field within the API definition for each consumer.
|
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.
| 0.088311
| 0.255814
|
44
|
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?
|
To track any internal changes within your API service component, you can use the 'internal' version of the API (e.g., v1).
|
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.
| 0.098656
| 0.171429
|
45
|
I've deployed a simple Python Flask microservice to Choreo without providing an OpenAPI specification. How will Choreo expose its endpoints by default?
|
Choreo will automatically expose the HTTP API (version 3) and WebSocket API (version 2) exposed by your service via the provided URL.
|
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.
| 0.024978
| 0.241379
|
46
|
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 level of granularity with the `@Secured` annotation provided by the `@SpringSecurity` package.
|
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.
| 0.028229
| 0.142857
|
47
|
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 create an API configuration in Choreo's UI and select 'GraphQL' as the API type for your SDL.
|
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.
| 0.128865
| 0.282051
|
48
|
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 associate an OpenAPI definition with a Go microservice's exposed endpoint, you should navigate to the 'OpenAPI' section within the 'Endpoints' tab of the Choreo dashboard.
|
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.
| 0.088394
| 0.293333
|
49
|
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 the `development` environment to `production`, you must first ensure that the API is set up to use the `--production` flag when running in the `production` environment. This can be done via the 'APIs' page within the Choreo interface and will automatically apply any changes made to your API configuration in this environment.
|
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.
| 0.164855
| 0.302521
|
50
|
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 create an `environment` with a `staging` environment. To set up the `staging` environment, add a new environment named `staging`, then change your application configuration from `development` to `staging`. This will ensure that all changes made in the `staging` environment will be reflected in the `development` environment as well.
|
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.
| 0.296374
| 0.208
|
51
|
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 `production` environment. This means that any changes made to this project will be immediately reflected across all production environments.
|
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.
| 0.156969
| 0.282353
|
52
|
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 set up environment-specific variables for your Docker container, you can use the following command: `docker run --env-file ./.env development`. This will automatically include any environment-specific variables defined in `.env`, including your externally provided API key.
|
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.
| 0.083868
| 0.258065
|
53
|
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 start using Choreo, you need to sign in to the Choreo dashboard at https://localhost:8080/ or go directly to 'Create' > 'Workspaces'. After creating your workspace, you can select it from the list on the left side of the page. As an example, if you're working on the 'Marketing' project, you could create a new workspace called 'Marketing' within 'My Workspaces', and then choose this newly created workspace when launching your application.
|
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.
| 0.06321
| 0.174603
|
54
|
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 achieve this, you can directly select the environment of any resource within your client's Choreo environment from the 'Resources' menu in the Choreo console. This allows for seamless management across different environments and ensures that users only need to log into one environment at a time.
|
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.
| 0.094554
| 0.186047
|
55
|
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 should add them to the 'API Manager' 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.
| 0.351764
| 0.433333
|
56
|
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 this scenario, you should assign the 'Finance' role to each user account associated with the Finance team within the organization.
|
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.
| 0.129625
| 0.246154
|
57
|
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 your Go microservice, you can assign a 'Developer' role. Since this is a new project with an automated CI/CD pipeline, it's advisable to set up a dedicated 'Developer' role for easy management of deployments, monitoring, and reliability.
|
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.
| 0.033642
| 0.133333
|
58
|
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 role with 'API' as their assigned role type.
|
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.
| 0.055771
| 0.275862
|
59
|
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 locate your Choreo organization's unique identifier (OUID) from the Choreo console, click on 'Organization' in the top navigation bar. Then, find the OUID under 'Details'. To copy this value to your clipboard, right-click it, and select 'Copy'.
|
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**.
| 0.061296
| 0.285714
|
60
|
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'?
|
The 'Organization Handle' is typically found in the `organizations.json` file within your organization's root directory.
|
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**.
| 0.04815
| 0.215385
|
61
|
What are the comprehensive administrative capabilities of a user assigned the 'Admin' role in Choreo? Can they manage more than just users?
|
The 'Admin' role has comprehensive administrative capabilities, enabling the management of all components within the Choreo platform, including services and components.
|
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.
| 0.028652
| 0.225806
|
62
|
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 in an efficient manner, you can use the 'one-to-one' deployment strategy. This approach allows for seamless integration between them without any conflicts or dependencies.
|
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.
| 0.023526
| 0.153846
|
63
|
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 the GoLang worker is accessible only from your Spring Boot application, you need to add the necessary CORS configuration for this worker.
|
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.
| 0.059418
| 0.193548
|
64
|
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 ensure that your public-facing React frontend is publicly available and your internal administrative API is only accessible from within your organization, you should use a dedicated service for each component.
|
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.
| 0.045271
| 0.150943
|
65
|
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 services in the same Choreo project, they will share the same Kubernetes namespace. However, this does not mean that they must communicate directly through the same network; they can communicate via a bridge or another intermediary.
|
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.
| 0.261268
| 0.366972
|
66
|
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' within a Choreo 'Container' aligns with a '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.
| 0.057174
| 0.208955
|
67
|
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, follow these steps:
1. Go to the 'Project' tab and then click 'Deploy'. This will take you to the 'Deployment Overview' page.
2. Click on 'New Environment'. This will open up a new page with details of the newly created environment.
3. Click 'Add', which brings up the 'Environment Configuration' page.
4. Select the environment from the dropdown menu at the top of the page. This will create a new section titled 'Environment Settings'.
5. Enter the name for this environment in the 'Name' field, select 'Development' as the environment type, and ensure that the 'Use existing content' checkbox is unchecked. This allows you to overwrite any existing content in the 'Content' tab, including API documentation and other files.
6. In the 'API' section, add a 'Node.js' label. This ensures that only Node.js code can be deployed in this environment.
7. Finally, click 'Save & Continue'.
This process will create an environment named 'development' within your 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.
| 0.140824
| 0.158879
|
68
|
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 can use the `choreo-kubernetes` configuration option in your `application.yml`. This configuration enables the utilization of multiple Kubernetes clusters within the same environment, ensuring high availability and efficient resource usage.
|
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.
| 0.10079
| 0.275862
|
69
|
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 the `staging` environment, you should deploy the same container image and use it within the `production` environment.
|
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`.
| 0.259883
| 0.285714
|
70
|
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 a new `development` environment in Choreo, it automatically creates a namespace named `dev`. This namespace is used to store your application code within a single namespace, ensuring that all components of your application share the same namespace. Additionally, Choreo uses a data plane called 'data-plane' to manage all services and resources, including databases and APIs.
|
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.
| 0.148285
| 0.27027
|
71
|
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 have multiple environments (`development`, `staging`, etc.) hosted 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.
| 0.18362
| 0.323529
|
README.md exists but content is empty.
- Downloads last month
- 4