vania-janet/multiturn-rag-retrieval-data huggingface dataset:
* Refer to the documentation pages and best practices to understand if you need these extra repositories for the applications.
* One inventory and issues repository should be enough, but you might want to have a different evidence repository for each application due to how "inhumanly" readable the repository structure is. And a separate repo helps you to know which application you're looking at.
* The Application repos can also serve as its own issues repo. That is, if the GitHub issues option is enabled on the tool integration.
* The Inventory repo should be enough as a single consolidated repository for recording your build records because the records are already divided by the app-name, so long as that parameter is different nothing is going to get lost or confused. Though you might want to consult the [inventory documentation](https://cloud.ibm.com/docs/devsecops?topic=devsecops-cd-devsecops-inventory) for ideas on how to handle this repo because its main function is to help support deployments in the continuous deployment pipeline.



3. Set up an IBM Cloud® Object Storage bucket.

Object Storage is the preferred evidence locker method for the pipeline evidence artifacts and is required for audit compliance. You must use the same Object Storage bucket for each application that you bring into the CI toolchain. You must also reuse the same Object Storage bucket when you are integrating your CI toolchain with CD or CC toolchain.
4. Optional: Extra HashiCorp Vault integrations.

Because the HashiCorp Vault tool integration supports only one path, you might need more of them depending on how your HashiCorp Vault secrets are configured. Different applications might need different or other credentials from each other.







 CI and PR pipeline changes 



1. Create a Git trigger for each application.



* The good news is that you can copy existing triggers, which can save you some tedium of creating triggers.
* Make sure each of the triggers is pointing to the wanted GitHub repository and branch.
* Make sure that the following trigger properties are set:
Using a compatible tool 

Some users want to use a stand-alone utility to interact with their storage. As the Cloud Object Storage API supports the most common set of S3 API operations, many S3-compatible tools can also connect to Object Storage by using [HMAC credentials](https://cloud.ibm.com/docs/cloud-object-storage?topic=cloud-object-storage-uhc-hmac-credentials-main).

Some examples include file explorers like [Cyberduck](https://cyberduck.io/) or [Transmit](https://panic.com/transmit/), backup utilities like [Cloudberry](https://www.cloudberrylab.com/) and [Duplicati](https://www.duplicati.com/), command-line utilities like [s3cmd](https://github.com/s3tools/s3cmd) or [Minio Client](https://github.com/minio/mc), and many others.





 Using the API 

Most programmatic applications of Object Storage use an SDK (such as [Java](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries?topic=cloud-object-storage-java), [node.js](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries?topic=cloud-object-storage-node), or [Python](https://cloud.ibm.com/docs/services/cloud-object-storage/libraries?topic=cloud-object-storage-python)) or the [Cloud Object Storage API](https://cloud.ibm.com/docs/services/cloud-object-storage/api-reference?topic=cloud-object-storage-compatibility-api). Typically objects are uploaded in [multiple parts](https://cloud.ibm.com/docs/services/cloud-object-storage/basics?topic=cloud-object-storage-large-objects), with part size and number of parts configured by a Transfer Manager class.





 Conditional requests
* [job update](https://cloud.ibm.com/docs/codeengine?topic=codeengine-clicli-job-update) command







 Runtime support 

Code Engine supports many of the runtimes that Cloud Foundry supports. For a list of runtimes that are supported by Code Engine, see [Cloud Native buildpacks](https://cloud.ibm.com/docs/codeengine?topic=codeengine-plan-buildbuild-buildpack-strat). If you want to use a runtime that is not supported, for example, Swift or Liberty, you can package your app as a container image yourself and [deploy that image in Code Engine](https://cloud.ibm.com/docs/codeengine?topic=codeengine-deploy-app) without building the image directly from Code Engine.







 Next steps 



1. Just starting your migration? Check out [Getting started](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-getstart).
2. [Compare Cloud Foundry terminology with Code Engine](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-terms).
3. [Try out Code Engine with a local build tutorial](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-local).
4. Does your application use service bindings? Check out [Migrating your service bindings](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-bind).
5. Learn about [scaling and traffic management](https://cloud.ibm.com/docs/codeengine?topic=codeengine-migrate-cf-ce-scale).
6.
--repositories (string)
: Repositories names.

--files (string)
: File names.

--archives (string)
: Archive Names.

--name (string)
: Name of the application.

--class (string)
: Entry point for a Spark application bundled as a '.jar' file. This is applicable only for Java or Scala applications.

The value must match the regular expression /([\p{L}_$]\.)[\p{L}_$]/.

--arg ([]string)
: An array of arguments to be passed to the application.

--conf (generic map)
: Application configurations to override the value specified at instance level. See [Spark environment variables](https://spark.apache.org/docs/latest/configuration.htmlavailable-properties) for a list of the supported variables.

--env (generic map)
: Application environment configurations to use. See [Spark environment variables](https://spark.apache.org/docs/latest/configuration.htmlenvironment-variables) for a list of the supported variables.





 Examples 

ibmcloud analytics-engine-v3 spark-app submit --arg "/opt/ibm/spark/examples/src/main/resources/people.txt" --app "/opt/ibm/spark/examples/src/main/python/wordcount.py" --runtime='{"spark_version": "3.1"}' --output json

ibmcloud analytics-engine-v3 spark-app submit --instance-id=e64c907a-e82f-46fd-addc-ccfafbd28b09 --arg "/opt/ibm/spark/examples/src/main/resources/people.txt" --app "/opt/ibm/spark/examples/src/main/python/wordcount.py" --runtime='{"spark_version": "3.1"}' --output json
This [blog post](https://blog.cloudant.com/2019/12/13/Filtered-Replication.html) describes how supplying a selector during replication makes work of these use cases run smoothly.

The changes feed with an accompanying selector parameter is not the way to extract slices of data from the database on a routine basis. It must not be used as a means of running operational queries against a database. Filtered changes are slow (the filter is applied to every changed document in turn, without the help of an index). This process is much slower than creating a secondary index (such as a MapReduce view) and querying that view.





 Does a feed=continuous changes feed continue to run indefinitely? 

No, IBM Cloudant does not guarantee connection duration for a continuous changes feed. It might be regularly disconnected by the server for any number of reasons, which include maintenance, security, or network errors. Code that uses the changes feed must be designed to use a recently saved sequence ID as a since value to make a new request to resume the changes feed after an error or disconnection.





 Why doesn't the changes feed guarantee time-ordering? 

If the use case is based on the following statement, then this result cannot be achieved with the IBM Cloudant changes feed.

"Fetch me every document that has changed since a known date, in the order they were written."

The IBM Cloudant database does not record the time as each document change was written. The changes feed makes no guarantees on the ordering of the changes in the feed - they are not guaranteed to be in the order they were sent to the database.

However, you can achieve this use case by storing the date of change in the document body:

{
"_id": "2657",
"type": "order",
"customer": "bob@aol.com",
"order_date": "2022-01-05T10:40:00",
"status": "dispatched",
"last_edit_date": "2022-01-14T19:17:20"
}

And you can create a MapReduce view with last_edit_date as the key:

function(doc) {
FAQs for GitHub, GitLab, and Git Repos and Issue Tracking 

Get answers to frequently asked questions about using GitHub, GitLab, and Git Repos and Issue Tracking.



 Can I manage GitHub, GitLab, and Git Repos and Issue Tracking by using Terraform? 

You can use Terraform to add GitHub, GitLab, and Git Repos and Issue Tracking tool integrations to a toolchain, to update those tool integrations, or to remove those tool integrations from a toolchain. For more information about working with the GitHub, GitLab, and Git Repos and Issue Tracking tool integrations, see [Working with tool integrations](https://cloud.ibm.com/docs/ContinuousDelivery?topic=ContinuousDelivery-integrations) and [Creating toolchains with Git](https://cloud.ibm.com/docs/ContinuousDelivery?topic=ContinuousDelivery-toolchains_git).

You might be able to use Terraform to work directly with some GitHub and GitLab repositories (repos). For more information about the GitHub Terraform provider, see the [GitHub Provider documentation](https://registry.terraform.io/providers/integrations/github/latest/docs). For more information about the GitLab Terraform provider, see the [GitLab Provider documentation](https://registry.terraform.io/providers/gitlabhq/gitlab/latest/docs).





 Can I manage GitHub, GitLab, and Git Repos and Issue Tracking by using an API? 

You can use HTTP APIs or selected programming language SDKs to add GitHub, GitLab, and Git Repos and Issue Tracking tool integrations to a toolchain, to update those tool integrations, or to remove those tool integrations from a toolchain.
* You must have at least one user ID in either the Admin or Project Manager role. For information about user roles, see [User roles in Knowledge Studio](https://cloud.ibm.com/docs/watson-knowledge-studio-data?topic=watson-knowledge-studio-data-roles).







 Results 

After you create the rule-based model, you can use it in one of the following ways to find text patterns in documents:



* [Pre-annotate your documents](https://cloud.ibm.com/docs/watson-knowledge-studio-data?topic=watson-knowledge-studio-data-preannotationwks_preannotrule) before you create a machine learning model
* [Deploy or export the model](https://cloud.ibm.com/docs/watson-knowledge-studio-data?topic=watson-knowledge-studio-data-wks_rule_publish) to other Watson services or products







 Lesson 1: Adding a dictionary of months 

In this lesson, you will learn how to add a dictionary to a workspace in Knowledge Studio. The dictionary contains terms related to the months of the year.



 About this task 

In a later lesson, you will define a class based on this dictionary. When you create that class, all terms in this dictionary that are found in documents will be automatically annotated as a mention of the associated class type. For more information about dictionaries, see [Adding dictionaries to a workspace](https://cloud.ibm.com/docs/watson-knowledge-studio-data?topic=watson-knowledge-studio-data-dictionarieswks_projdictionaries).





 Procedure 



1. Download the [dictionary-items-month.csv![External link icon](https://cloud.ibm.com/docs-content/v1/content/icons/launch-glyph.svg)](https://watson-developer-cloud.github.io/doc-tutorial-downloads/knowledge-studio/dictionary-items-month.csv) file to your computer.
hello-iac-sample_schematics-workspace-name : workspace-for-deployment-of-hello-iac-sample



 Configuration to use Terraform CLI as deployment tool 



Table 9. Configuration to use Terraform CLI as deployment tool

 Property Description 

 tf-backend-s3-bucket Bucket name that stores the state. 
 tf-backend-s3-key Name to use to persist the state. 
 tf-backend-s3-region Region of the Cloud Object Storage instance. 
 tf-backend-s3-endpoint Cloud Object Storage endpoint. 
 tf-backend-s3-access_key HMAC access_key subsection of the credentials. 
 tf-backend-s3-secret_key HMAC secret_key subsection of the credentials. 



Note the following:



* For more information on how to use the Cloud Object Storage endpoint or bucket to store Terraform state, see: [Store Terraform states in Cloud Object Storage](https://www.ibm.com/cloud/blog/store-terraform-states-cloud-object-storage).
* To configure the scripts in the IaC CD deployment process, define the parameter that is scoped for an inventory entry. To specify Terraform CLI as deployment tool-related environment properties for a scope (inventory entry), prefix the property with the inventory entry name, for example: <inventory_entry>_. This prefix applies for the all the schematics-related environment entries.



Example:

hello-iac-sample_tf-backend-s3-bucket : bucket-to-store-tfstate-of-hello-iac-sample









 Release to inventory 

Use the release to inventory user script stage to add artifacts to the inventory by using the cocoa inventory add CLI command. For more information about cocoa inventory add, see [cocoa inventory add](https://cloud.ibm.com/docs/devsecops?topic=devsecops-cd-devsecops-cliinventory-add).
application: '/opt/ibm/spark/examples/src/main/python/wordcount.py',
arguments: ['/opt/ibm/spark/examples/src/main/resources/people.txt'],
};

ibmAnalyticsEngineApiService.createApplication({
instanceId: 'e64c907a-e82f-46fd-addc-ccfafbd28b09',
applicationDetails: applicationRequestApplicationDetailsModel,
}).then((res) => {
console.log(JSON.stringify(res.result, null, 2));
}).catch((err) => {
console.warn(err);
});
* Retrieve all Spark applications run on a given instance:

listApplications(params)

Example request:

ibmAnalyticsEngineApiService.listApplications({
instanceId: 'e64c907a-e82f-46fd-addc-ccfafbd28b09',
}).then((res) => {
console.log(JSON.stringify(res.result, null, 2));
}).catch((err) => {
console.warn(err);
});
* Retrieve the details of a given Spark application:

getApplication(params)

Example request:

ibmAnalyticsEngineApiService.getApplication({
instanceId: 'e64c907a-e82f-46fd-addc-ccfafbd28b09',
applicationId: 'db933645-0b68-4dcb-80d8-7b71a6c8e542',
}).then((res) => {
console.log(JSON.stringify(res.result, null, 2));
}).catch((err) => {
The sample below demonstrates how to do some table maintenance operations by using Spark. For more information about the Iceberg Spark table maintenance operations, see [Table Operations](https://iceberg.apache.org/docs/1.2.1/spark-procedures/).







 Running the sample use case 

Follow the steps to run the Spark sample python file.



 Spark sample python file 

from pyspark.sql import SparkSession
import os

def init_spark():
spark = SparkSession.builder .appName("lh-hms-cloud") .config("spark.hadoop.fs.s3a.bucket.lakehouse-bucket.endpoint" ,"s3.direct.us-south.cloud-object-storage.appdomain.cloud") .config("spark.hadoop.fs.s3a.bucket.lakehouse-bucket.access.key" ,"<access-key-for-source-bucket>") .config("spark.hadoop.fs.s3a.bucket.lakehouse-bucket.secret.key" ,"<secret-key-for-source-bucket>") .config("spark.hadoop.fs.s3a.bucket.source-bucket.endpoint" ,"s3.direct.us-south.cloud-object-storage.appdomain.cloud") .config("spark.hadoop.fs.s3a.bucket.source-bucket.access.key" ,"<access-key-for-lakehous-bucket>") .config("spark.hadoop.fs.s3a.bucket.source-bucket.secret.key" ,"<secret-key-for-lakehouse-bucket>") .enableHiveSupport() .getOrCreate()

return spark

def main():
try:
spark = init_spark()
 Create a database in lakehouse catalog
spark.sql("create database if not exists lakehouse.demodb LOCATION 's3a://lakehouse-bucket/'")
 list the database under lakehouse catalog
* [IBM Cloud Foundry migration tooling](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-deprecation_migration_tooling)
* [Migrating Liberty applications to Paketo Cloud Native buildpacks](https://www.ibm.com/cloud/blog/migrate-your-cloud-foundry-liberty-for-java-applications-to-the-paketo-buildpack-for-liberty)



* [What is Cloud Foundry?](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-what-is-cloud-foundry)
* [How Cloud Foundry works with IBM Cloud](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-howwork)
* [Regions and endpoints](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-endpoints)
* Best practices



* [What makes a good Cloud Foundry app?](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-goodapp)
* [Best practices for running apps in production](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-production)



* [Release notes](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-cloud-foundry-public-release-notes)



* How to



* Setting up your IBM Cloud environment



* [Design the structure of your environment](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-bpimplementation)
* [Determining your organization architecture](https://cloud.ibm.com/docs/cloud-foundry-public?topic=cloud-foundry-public-orgstructure)
Avoiding invariants makes it more likely that a simple merge operation, if you take the changed field from each conflicted document revision, is suitable. This practice makes simpler and more robust application code.
* Allow documents to be independent. If you have to retrieve other documents to work out the correct resolution, it increases latency in conflict resolution. There's also a chance you get a version of the other documents that aren't consistent with the document you're resolving, making correct resolution difficult.



* Why do I need to build in conflict resolution

Heavily conflicted documents exert a heavy toll on the database. Building in the capability to resolve conflicts from the beginning is a great help in avoiding pathologically conflicted documents.
* Where can I get more information?

These tips demonstrate how modeling data affects your application’s performance. IBM Cloudant’s data store has some specific characteristics, both to watch out for and to take advantage of, that ensure the database performance scales as your application grows. IBM Cloudant support understands the shift can be confusing, so they are always available to give advice.

For more information, see the [data model for Foundbite](https://cloudant.com/blog/foundbites-data-model-relational-db-vs-nosql-on-cloudant/), or the [example from our friends at Twilio](https://www.twilio.com/blog/2013/01/building-a-real-time-sms-voting-app-part-3-scaling-node-js-and-couchdb.html).
* Pricing FAQ

 Pricing FAQ 

IBM Cloudant pricing is based on the provisioned throughput capacity that you set for your instance, and the amount of data storage you use.

With IBM® Cloudant® for IBM Cloud®, you can increase or decrease your provisioned throughput capacity as needed, and pay pro-rated hourly. The provisioned throughput capacity is a reserved number of reads per second, writes per second, and global queries per second allocated to an instance. The throughput capacity setting is the maximum usage level for a given second.
* [Submitting similar batch jobs](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cebatchjobsbatchjob-reuse)
* [Triggering batch jobs with events](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cebatchjobsbatchjob-eventing)



* [How can I get started with batch jobs?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cebatchjobsbatchjob-getstart)



[Function workloads](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionscefunctions)



* [Lifecycle of a Function instance](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionsfunctions-lifecycle)
* [How do Functions compare to apps and jobs?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionsfunctions-work-compare)
* [What are key features of working with Functions?](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionsfunctions-work-ce)



* [Isolation](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionscefun-isolation)
* [Logging](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionsfunctions-logging)
* [Runtimes](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionsfunctions-runtime)
* [Running Functions](https://cloud.ibm.com/docs/codeengine?topic=codeengine-cefunctionscefun-runfun)
[Setting up a bastion host that uses Teleport](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-connectivity-bastion-tutorial-teleport)Setting up a bastion host that uses Teleport

This tutorial shows you one way that can be used to meet the IBM Cloud Framework for Financial Services requirements that are related to bastion host. There are various ways to implement a compliant bastion solution, but we show you how to configure a bastion host in your VPC by using Teleport Enterprise Edition, along with Object Storage and App ID for enhanced security. You will learn how to set up a Teleport-based solution that meets the previously described IBM Cloud Framework for Financial Services requirements.

Object Storage App ID

+2

Virtual Private Cloud (VPC),IBM Cloud Framework for Financial Services



* 2 hours
* 2023-05-11



[Setting capacity quotas for apps that use IBM Cloud Object Storage](https://cloud.ibm.com/docs/openshift?topic=openshift-storage-cos-tutorial-quota)Setting capacity quotas for apps that use IBM Cloud Object Storage

With IBM Cloud Object Storage, you can dynamically provision buckets for apps running in your Red Hat OpenShift on IBM Cloud clusters. You can also dynamically set capacity quotas on those buckets during provisioning. Quotas can help you manage the resources your workloads use while also avoiding unnecessary charges.

Red Hat OpenShift on IBM Cloud Object Storage



* 45 minutes
* 2023-02-16



[Access a storage bucket by using a dynamic secret](https://cloud.ibm.com/docs/secrets-manager?topic=secrets-manager-tutorial-access-storage-bucket)Access a storage bucket by using a dynamic secret

In this tutorial, you learn how to use IBM Cloud® Secrets Manager to create and lease an IAM credential that can be used to access a bucket in Cloud Object Storage.

Secrets Manager Object Storage



* 1 hour
* 2023-05-30
Composer 

With Composer, IBM Cloud® Functions supports conductor actions, which extends sequences with more combinators ([JS](https://github.com/ibm-functions/composer/blob/master/docs/COMBINATORS.md), [Python](https://github.com/ibm-functions/composer-python/blob/master/docs/COMBINATORS.md)) By using Composer, you can create more complex flows that include conditional branching, error handling, retries, and loops.



 Installing the Composer library for JavaScript or Python 

You can use Composer with actions that are written in any language, but you express the composition in either JavaScript or Python. After the installation, you can use the Composer compose/pycompose and deploy/pydeploy commands to [configure and run a composition](https://cloud.ibm.com/docs/openwhisk?topic=openwhisk-pkg_composerrun).



 For JavaScript 



1. Install the Composer library [Node.js package](https://github.com/ibm-functions/composer) by using the Node Package Manager.

npm install -g @ibm-functions/composer
2. Confirm that you installed the library by running help for the Composer commands.

compose -h
deploy -h

The following example shows possible output for the Composer commands.

Usage:
compose composition.js [flags]

Usage:
deploy composition composition.json [flags]







 For Python 

Install the [Composer for Python](https://github.com/ibm-functions/composer-python) library by using pip3.



1. Install the Composer library.

pip3 install git+https://github.com/ibm-functions/composer-python.git
2. Confirm that you installed the library by running help for the Composer commands.

pycompose -h
pydeploy -h

Example output

usage: pycompose composition.py command [flags]

usage: pydeploy composition composition.json [flags]