vania-janet/multiturn-rag-retrieval-data huggingface dataset:
[hamburger icon](https://cloud.ibm.com/docs-content/v1/content/562806c0b18119f4d21cb66f5ae6d051634b4a16/ContinuousDelivery/images/icon_hamburger.svg) and select DevOps. On the Toolchains page, click a toolchain to open its Overview page. Alternatively, on your app's Overview page, on the Continuous delivery card, click View toolchain.
2. On the Delivery pipelines card, click the Delivery Pipeline Private Worker tool integration that you want to configure.
3. Click Getting Started and then follow the steps to install and register a private worker on your Kubernetes cluster.







 Using the Delivery Pipeline Private Worker in your pipeline 

Complete the following steps to use the private worker in your pipeline:



1. From the IBM Cloud console, click the menu icon ![hamburger icon](https://cloud.ibm.com/docs-content/v1/content/562806c0b18119f4d21cb66f5ae6d051634b4a16/ContinuousDelivery/images/icon_hamburger.svg) and select DevOps. On the Toolchains page, click a toolchain to open its Overview page. Alternatively, on your app's Overview page, on the Continuous delivery card, click View toolchain.
2. On the Delivery pipelines card, click the pipeline that you want to use the private worker with.
3. If you are using a Classic pipeline, on the Pipeline page, on the stage, click the Stage Configuration icon. Then, click Configure Stage and click the Workers tab.
4. If you are using a Tekton pipeline, from the trigger for which you want to specify a worker, select the Workers page.
5. Select the private worker that you want to use in your pipeline.

By default, pipeline jobs and pipeline runs are run by using a pool of IBM-managed shared workers in the region where the pipeline is defined.
6. Click Save.
7.
* [Using IBM Cloud HSM](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-using)
* [Process overview](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-overview)



* [Part One: Set up the HSM device and HSM client](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-part-one)
* [Part Two: Configure communications between the HSM server and client](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-part-two)
* [Part Three: Register the client with the HSM server](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-part-three)
* [Part Four: Build a Docker image](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-part-four)
* [What's next](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-hsm-gemaltoibp-hsm-gemalto-next-steps)





[Using certificates from an external Certificate Authority](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-tutorial-extcaibp-tutorial-extca)
For the tool integration type, select Nexus.

d. For the build command, enter the commands to build your Maven module or publish it to your snapshot registry. This example shows the commands to either build the module or publish it.

mvn -B clean package
 or
mvn -DaltDeploymentRepository="snapshots::default::${MAVEN_SNAPSHOT_URL}" deploy

You can find the URL and user credentials that you used to connect to your registry in the configuration settings for the Nexus tool integration.
4. Click SAVE. Whenever your pipeline runs, this build job uses the configuration information from the Nexus tool integration to connect to your Maven repo.







 Configuring Nexus by using the API 

The Nexus tool integration supports the following configuration parameters that you can use with the [Toolchain HTTP API and SDKs](https://cloud.ibm.com/apidocs/toolchain) when you [create](https://cloud.ibm.com/apidocs/toolchaincreate-tool), [read](https://cloud.ibm.com/apidocs/toolchainget-tool-by-id), and [update](https://cloud.ibm.com/apidocs/toolchainupdate-tool) tool integrations.

You must specify the tool_type_id property in the request body with the nexus value.



Table 1. Nexus tool integration parameters

 Parameter Usage Type Terraform argument Description 

 dashboard_url optional, updatable String server_url The URL of the Nexus server dashboard for this tool integration. In the graphical UI, the browser goes to this dashboard when you click the Nexus tool integration card. 
 mirror_url optional, updatable String mirror_url The URL of your Nexus virtual repo where you can view your private repos and a cache of the public repos. 
 name required, updatable String name The name of this tool integration. 
 release_url optional, updatable String release_url The URL of your Nexus release repo.
In order for a smart contract to work with Node v12 runtime, the fabric-contract-api and fabric-shim node modules must be at v1.4.5 or greater. If you are using a smart contract that was originally written to work with Fabric 1.4, update the Node modules by running the following command before deploying the smart contract on a Fabric v2.x peer. See [Support and compatibility for fabric-chaincode-node](https://github.com/hyperledger/fabric-chaincode-node/blob/main/COMPATIBILITY.md) for more information.

npm install --save fabric-contract-api@latest-1.4 fabric-shim@latest-1.4

Go

Because Fabric v2.x peers do not have a "shim" (the external dependencies that allowed smart contracts to run on earlier versions of Fabric), you need to vendor the shim and then repackage any smart contracts written in Golang (Go) that use the [Go SDK](https://github.com/hyperledger/fabric-sdk-go). "Vendoring the shim" effectively means that you are copying the dependencies into your project. Without this vendoring and repackaging, the Go smart contract cannot run on a peer using a Fabric 2.x image. If you are using the [IBM Developer Tools](https://cloud.ibm.com/docs/blockchain?topic=blockchain-develop-vscode) to develop and package your smart contract, the tooling performs the vendoring for you. This process is not required for smart contracts that are written in Java or Node.js, nor for Go smart contracts that use the [Go contract-api](https://github.com/hyperledger/fabric-contract-api-go).

Java
The build.gradle file for the smart contract must be updated:



1. If the smart contract uses the shadowjar 2.x plugin, then it should be updated to version 5 by using the following code:

plugins {
id 'com.github.johnrengelman.shadow' version '5.1.0'
The sample code also includes examples of how you can import certificates into a [wallet](https://hyperledger-fabric.readthedocs.io/en/release-2.2/developapps/wallet.html) and use your connection profile to build a [Fabric gateway](https://hyperledger-fabric.readthedocs.io/en/release-2.2/developapps/gateway.html). The tutorial can be used by two different organizations to complete different transactions with a single asset. If you used the [Build a network tutorial](https://cloud.ibm.com/docs/blockchain?topic=blockchain-ibp-console-build-networkibp-console-build-network) to deploy two peer organizations that are connected to a channel, you can interact with the tutorial by using both organizations.

Use the following steps to deploy the sample on your network. You can review the tutorial in the Fabric Documentation [commercial paper tutorial](https://hyperledger-fabric.readthedocs.io/en/release-2.2/tutorial/commercial_paper.html) for more details about the smart contracts and the application structure.



 Prerequisites 

Before you can deploy the commercial paper sample, you need to install required tools on your local machine:



* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)
* [Node.js](https://hyperledger-fabric.readthedocs.io/en/release-2.2/prereqs.htmlnode-js-runtime-and-npm)



You will also need a use text editor to edit and save files in the sample. You can use many of the high-quality editors that are available for free, such as [Visual Studio Code](https://code.visualstudio.com/), [Atom](https://atom.io/), [Sublime text](http://www.sublimetext.com/), or [Brackets](http://brackets.io/).





 Step one: Download the sample
Step 7: Create an Event Notifications subscription 

Click Subscriptions in the Event Notifications console. Enter the following subscription details:



* Click Create to display subscription wizard.
* Complete the following subscription details:



* Subscription name: name of the subscription.
* Subscription description: add an optional description.



* Under the Subscribe to a topic section, select a topic from the drop-down list and select a destination from the destination drop-down list.
* Destination type: select type under Destination and click Add.







 Step 8: Set up Event Notifications Android SDK 

The Android SDK enables Android apps to receive push notifications. Complete the following steps to install Event Notifications Android SDK, initialize the SDK, and register for notifications for your Android app.



* Install Event Notifications by using Gradle.

compile 'com.ibm.cloud:eventnotifications-destination-android:0.0.1'
* Follow [event-notifications-destination-android-sdk](https://github.com/IBM/event-notifications-destination-android-sdk) to install the SDK.
* When Gradle is installed, [import and initialize](https://github.com/IBM/event-notifications-destination-android-sdkinitialize-sdk) the SDK.

import com.ibm.cloud.eventnotifications.destination.android.ENPush;

String instanceGUID = "<instance_guid>>";
String destinationID = "<instance_destination_id>";
String apiKey = "<instance_apikey>";

ENPush enPush = ENPush.getInstance();
enPush.setCloudRegion(ENPush.REGION_US_SOUTH); // Set your region

enPush.initialize(getApplicationContext(),instanceGUID,destinationID, apiKey);
* When the SDK is initialized, [register](https://github.com/IBM/event-notifications-destination-android-sdkregister-for-notifications) for push notifications.
* [Custom endpoint for exposing-metrics](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-monitoring-operational-tutorialstep5-configure-monitoring-virtual-server-instance-custom-endpoint)



* [Set up a custom Grafana dashboard](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-monitoring-operational-tutorialstep6-set-up-a-custom-grafana-dashboard)
* [Related controls in IBM Cloud Framework for Financial Services](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-monitoring-operational-tutorialrelated-controls)







 Bastion host 

[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-teleportvpc-architecture-connectivity-bastion-tutorial-teleport)



* [Before you begin](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-connectivity-bastion-tutorial-teleportsetup-prereqs)
* [Limitations](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-connectivity-bastion-tutorial-teleportteleport-limitations)
* [Configure Object Storage](https://cloud.ibm.com/docs/framework-financial-services?topic=framework-financial-services-vpc-architecture-connectivity-bastion-tutorial-teleportsetup-install-cloud-object-storage)
Open your terminal and change your working directory to the COS-WebGalleryStart directory. Note the Node.js dependencies that are listed in the package.json file. Download them into place by using the command shown next.

npm install
3. Run the app by using the command shown.



npm start

Open a browser and view your app on the address and port that is output to the console, http://localhost:3000.

To restart the app locally, kill the node process (Ctrl+C) to stop it, and use npm start again. Using nodemon instead restarts the app when it detects a change, and saves you time. Install nodemon globally like this: npm install -g nodemon. Run it from the command line in your app directory by using: nodemon, to start your app.



1. Get ready to prepare the app for deployment! Update the application name property value in the manifest.yml file from COS-WebGallery, to the name you entered for your app on IBM Cloud Platform and the other information as shown in the example, if necessary. The application manifest.yml looks like the following example. You can customize the package.json file that is located in the app root directory for your app with the name of your app and your name as the author.



applications:
- path: .
memory: 256M
instances: 1
domain: us-south.cf.appdomain.cloud
name: webapplication
host: webapplication
disk_quota: 1024M
random-route: true

Now is the point where you might need to set up SSH keys to interactively push code to your remote origin. If you set a passphrase for your SSH key, you're required to enter this code each time you push your changes to the remote origin for your repository.



1. Remove and replace the contents of your webapplication directory with the contents of the directory you modified, COS-WebGalleryStart.
Setting up the CLI 

Use the IBM Cloud Schematics command-line plug-in to automate the infrastructure provisioning process, the configuration of your resources, and the deployment of app workloads. The IBM Cloud® Schematics command-line supports the following platform architectures:



* Mac OS X 64-bit
* Mac OS arm64
* Windows™ 64-bit
* Windows™ 32-bit
* Linux™ 64-bit
* Linux™ arm64
* Linux™ 32-bit
* PowerLinux™ 64-bit
* System/390 Linux™ 64-bit





 Installing the IBM Cloud command-line 

Install the required command-line to start using IBM Cloud Schematics.



1. Install the [IBM Cloud CLI](https://cloud.ibm.com/docs/cli?topic=cli-getting-started).

Plan to use the command-line often? Try [Enabling shell auto completion for IBM Cloud command-line (Linux/MacOS only)](https://cloud.ibm.com/docs/cli?topic=cli-shell-autocompleteshell-autocomplete-linux).
2. Log in to the IBM Cloud CLI. Enter your IBM Cloud credentials when prompted.

ibmcloud login

If you have a federated ID, use ibmcloud login --sso to log in to the IBM Cloud CLI. Enter your user name and use the provided URL in your command-line output to retrieve your one-time passcode. You know that you have a federated ID when the login fails without the --sso and succeeds with the --sso option.







 Installing the IBM Cloud Schematics command-line plug-in 

Install the IBM Cloud Schematics plug-in to automate cloud operations, configuration management, and infrastructure deployments.



1. Install the IBM Cloud command-line plug-in for Schematics.

ibmcloud plugin install schematics
2. Verify that the IBM Cloud Schematics command-line plug-in is installed successfully. The plug-in is listed as schematics.
Before you begin, [review the packages that are included with the JavaScript runtime](https://cloud.ibm.com/docs/openwhisk?topic=openwhisk-runtimesopenwhisk_ref_javascript_environments) to see whether a dependency of your app is already included with the runtime. If your dependency is not included, you must package it with your app. The following steps assume that you are running the commands on a Linux-based distribution on a processor with AMD64-based architecture.



1. Create a package.json file. Add webpack as a development dependency.

{
"name": "my-action",
"main": "dist/bundle.js",
"scripts": {
"prebuild": "NODE_ENV=development npm install",
"build": "webpack --config webpack.config.js ",
"deploy": "ibmcloud fn fn action update my-action dist/bundle.js --kind nodejs:16",
"clean": "rm -rf node_modules package-lock.json dist"
},
"dependencies": {
"left-pad": "1.1.3"
},
"devDependencies": {
"webpack": "^5.72.0",
"webpack-cli": "^4.9.2"
}
}
Show more
2. Save the following webpack configuration code in a file named webpack.config.js.

var path = require('path');
module.exports = {
entry: './index.js',
output: {
path: path.resolve(__dirname, 'dist'),
filename: 'bundle.js'
},
target: 'node'
};
3. Prepare your app code.
If your smart contract needs to include the Init function, the only way to deploy it is by using the Fabric [peer lifecycle chaincode install](https://hyperledger-fabric.readthedocs.io/en/release-2.2/commands/peerlifecycle.htmlpeer-lifecycle-chaincode-install) command or the [IBM Blockchain Platform collection for Ansible](https://ibm-blockchain.github.io/ansible-collection/). You can also refer to the [Fabric documentation](https://hyperledger-fabric.readthedocs.io/en/release-2.2/chaincode_lifecycle.htmlstep-three-approve-a-chaincode-definition-for-your-organization) for more details on how to use an Init function with the Fabric chaincode lifecycle.

Repackage smart contract

Attention! The IBM Blockchain Platform Extension for VS Code (VS Code extension) referenced throughout the documentation is an open-source project which is no longer active, and therefore not officially supported by IBM. Refer to the [alternatives to the VS Code extension](https://github.com/IBM-Blockchain/blockchain-vscode-extension/issues/3159).

After you have updated your smart contract, use [v2](https://cloud.ibm.com/docs/blockchain?topic=blockchain-develop-vscodedevelop-vscode-installing-the-extension) of the VS Code extension to [repackage](https://cloud.ibm.com/docs/blockchain?topic=blockchain-develop-vscodepackaging-a-smart-contract) your smart contract.







 Step three: Package a smart contract 

You need to package a smart contract before you can install it on your IBM Blockchain Platform network or the preconfigured Hyperledger Fabric network. Fabric V1 channels require smart contract packages to be in the .cds format, and V2 require the .tar.gz format. Complete the following steps to package your smart contract:



1.
ibmcloud plugin install container-registry
ibmcloud plugin install cloud-object-storage
ibmcloud plugin install kubernetes-service
ibmcloud plugin install vpc-infrastructure
ibmcloud plugin install code-engine

To see all the available plugins, run ibmcloud plugin repo-plugins and to install a plugin ibmcloud plugin install <PLUGIN_NAME>







 GitHub account 



1. Sign up for a free account at [https://github.com/](https://github.com/).
2. Create a new public repository at [https://github.com/new](https://github.com/new) to get familiar with GitHub.







 IBM Cloud GitLab 

IBM Cloud provides you with hosted Git repositories built on GitLab Community Edition and accessible with the same credentials used to log in IBM Cloud. It is recommended to configure your SSH public key to simplify the command line interactions with the Git repositories.



1. [Use these instructions](https://us-south.git.cloud.ibm.com/help/user/ssh.mdgenerate-an-ssh-key-pair) to generate a new SSH key pair if you don't have one.
2.
For more information, see [Toolchain availability, templates, and tutorials](https://cloud.ibm.com/docs/ContinuousDelivery?topic=ContinuousDelivery-cd_about). You can find several DevOps-based tutorials in the “Tutorials” section of the [Continuous Delivery docs](https://cloud.ibm.com/docs/ContinuousDelivery).
* [Set up continuous deployment with Schematics and DevOps toolchain](https://cloud.ibm.com/schematics?topic=schematics-workspace-continuous-deployment).
* View the [tutorials for deploying a secure app with DevSecOps](https://cloud.ibm.com/docs/devsecops).
* Browse or search the [IBM Cloud catalog](https://cloud.ibm.com/catalog) for apps and services that you can create and use today.
* [IBM Developer code patterns](https://developer.ibm.com/patterns/) help you quickly create your app and deploy it to IBM Cloud.
* Use the following tutorials to use IBM Cloud Schematics to create and deploy apps:



* [Deploy a Node.js Express app by using IBM Cloud Schematics](https://cloud.ibm.com/docs/apps?topic=apps-tutorial-node-webapp)
* [Deploy a Java Spring app by using IBM Cloud Schematics](https://cloud.ibm.com/docs/apps?topic=apps-tutorial-spring-webapp)
* [Deploy a Java Liberty app by using IBM Cloud Schematics](https://cloud.ibm.com/docs/apps?topic=apps-tutorial-liberty-webapp)



* Check out the Tutorials section in the navigation menu to find more ways to create and deploy apps.
This directory contains the installation files for gemalto/luna client
COPY 64 64

RUN microdnf install -y 
gcc 
gcc-c++ 
openssh-clients 
bind-utils 
iputils 
&& cd 64 && 
 NOTE we are accepting the license for installing gemalto client here
 please take a look at the license before moving forward
echo "y" | ./install.sh -p sa

 Final image 

FROM registry.access.redhat.com/ubi8/ubi-minimal

 Copy the library files from builder
COPY --from=builder /usr/lib/libCryptoki2_64.so /usr/lib/libCryptoki2_64.so
COPY --from=builder /usr/lib/libCryptoki2_64.so.2 /usr/lib/libCryptoki2_64.so.2
COPY --from=builder /usr/lib/libCryptoki2_64.so.6.3.0 /usr/lib/libCryptoki2_64.so.6.3.0
Show more

Now, run the following command to build the Docker image:

docker build -t hsm-client:v1 -f Dockerfile .





 Step three: Push the Docker image to your container registry 

After the image is built, the next step is to push the image to your Docker registry (for example, Docker Hub). The commands look similar to:

docker login -u <DOCKER_HUB_ID> -p <DOCKER_HUB_PWD>
docker tag hsm-client:v1 <DOCKER_HUB_ID>/hsm-client:v1
docker push <DOCKER_HUB_ID>/hsm-client:v1



* Replace <DOCKER_HUB_ID> with your Docker Hub id.
* Replace <DOCKER_HUB_PWD> with your Docker Hub password.



Create a Kubernetes image pull secret
Deploy a Java Liberty app by using IBM Cloud Schematics 

In this tutorial, you learn how to create and deploy a scalable Java Liberty application. This scalable web app offers a one-click option to create an IBM Cloud® Schematics workspace with your choice of preconfigured Terraform templates. The Terraform templates deploy your app to IBM Cloud with options for the deployment target (Kubernetes or Red Hat® OpenShift®) and the DevOps toolchain pipeline structure.

IBM Cloud Schematics delivers Terraform-as-a-Service so that you can use a high-level scripting language to model the resources that you want in your IBM Cloud environment, and enable Infrastructure as Code (IaC). [Terraform](https://www.terraform.io/) is an open source software that is developed by HashiCorp that enables predictable and consistent resource provisioning to rapidly build complex, multitier cloud environments.

In this tutorial, you follow two easy steps to create a Schematics workspace and apply a Terraform execution plan. When you apply the plan, a Kubernetes or OpenShift cluster is created, and a Java Liberty application is deployed to it by using an IBM Cloud DevOps toolchain.

Two types of DevOps toolchain pipeline structures are available with this app:



* Classic pipeline structure
* Tekton "GitSecure" pipeline structure



Both toolchain template options offer a code repository, delivery pipelines, and web IDE.



 Before you begin 



* Set up an [IBM Cloud account](https://cloud.ibm.com/registration). Depending on your IBM Cloud account type, access to certain resources might be limited. Depending on your account plan limits, certain capabilities that are required by some DevOps toolchains might not be available. For more information, see [Setting up your IBM Cloud account](https://cloud.ibm.com/docs/account?topic=account-account-getting-started) and [Upgrading your account](https://cloud.ibm.com/docs/account?topic=account-upgrading-account).







 Step 1: Create a Schematics workspace 



1.