vania-janet/multiturn-rag-retrieval-data huggingface dataset:
App networking You can create a Kubernetes LoadBalancer service for your apps in the cluster, which automatically provisions a VPC load balancer in your VPC outside the cluster. The load balancer is multizonal and routes requests for your app through the private NodePorts that are automatically opened on your worker nodes. For more information, see [Exposing apps with VPC load balancers](https://cloud.ibm.com/docs/containers?topic=containers-vpc-lbaas). Calico is used as the cluster networking policy fabric. 
 Storage You can set up only block persistent storage. Block storage is available as a cluster add-on. For more information, see [Setting up IBM Block Storage for IBM Cloud](https://cloud.ibm.com/docs/containers?topic=containers-block_storage). 







 Overview of personal and sensitive data storage and removal options 

Review what information is stored with IBM when you use IBM Cloud Kubernetes Service, how this data is stored and encrypted, and how you can permanently remove this information.



 What information is stored with IBM when using IBM Cloud Kubernetes Service? 

For each cluster that you create with IBM Cloud Kubernetes Service, IBM stores the information that is described in the following table:



Table 1. Information that is stored with IBM

 Information type Data 

 Personal information The email address of the IBM Cloud account that created the cluster. 
 Sensitive information <br><br> * The TLS certificate and secret that is used for the assigned Ingress subdomain.<br> * The certificate authority that is used for the TLS certificate.<br> * The certificate authority, private keys, and TLS certificates for the Kubernetes master components, including the Kubernetes API server, etcd data store, and VPN.<br> * A customer root key in IBM Key Protect for each IBM Cloud account that is used to encrypt personal and sensitive information.<br><br><br> 







 How is my information stored and encrypted? 

All information is stored in an etcd database and backed up every 8 hours to IBM Cloud Object Storage.
The development and testing clusters can start with minimum RAM and CPU option (for example 2 CPU's, 4GB of RAM and one worker node for each cluster).
3. For the production cluster, you might want to have more resources for performance, high availability, and resiliency. We might choose a dedicated or even a bare metal option and have at least 4 CPU's, 16GB of RAM, and two workers nodes.







 Decide what Database option to use 

With Kubernetes, you have two options for handling databases:



1. You can run your database inside the Kubernetes cluster, to do that you would need to create a microservice to run the database. For example, if you are using a MySQL database, you would need to complete the following steps:



* Create a MySQL Dockerfile, see an example [MySQL Dockerfile](https://github.com/IBM-Cloud/jpetstore-kubernetes/blob/master/jpetstore/db/Dockerfile) here.
* You would need to use secrets to store the database credential. See example of this [here](https://github.com/IBM-Cloud/jpetstore-kubernetes/blob/master/jpetstore/db/Dockerfile.secret).
* You would need a deployment.yaml file with the configuration of your database to deployed to Kubernetes. See example of this [here](https://github.com/IBM-Cloud/jpetstore-kubernetes/blob/master/jpetstore/jpetstore.yaml).



2. The second option would be to use the managed database-as-a-service (DBaaS) option. This option is usually easier to configure and provides built-in backups and scaling. You can find many different types of databases in the [IBM Cloud catalog](https://cloud.ibm.com/catalog?category=databasesservices). To use this option, you would need to do the following:
Continuous delivery practices 

With IBM Cloud® Continuous Delivery, you can build, test, and deliver applications by using DevOps or DevSecOps practices and industry-leading tools. Continuous Delivery supports a wide variety of practices; but which practices should you use? There is no one-size-fits-all answer. The practices you employ can vary from one software delivery project to the next. The [IBM Cloud Garage Method](https://www.ibm.com/garage/method/) is the IBM approach to rapidly deliver engaging applications. It combines continuous delivery with IBM Design Thinking, lean, DevOps, and agile practices. Those practices are focused on the cloud, but can benefit any software development effort.



 Adopting continuous delivery practices 

To learn how to adopt a continuous delivery approach in your organization, use these Cloud Garage Method articles, tutorials and online courses, which are arranged from basic to advanced.





 Continuous delivery articles 

The Cloud Garage Method site contains articles that describe continuous delivery at a high level.

[Continuous Delivery](https://www.ibm.com/garage/method/practices/deliver/practice_continuous_delivery/) is a practice by which you build and deploy your software so that it can be released into production at any time. One of the hallmarks of computer science is the shortening of various cycle times in the development and operations process.

With [Delivery Pipeline](https://www.ibm.com/garage/method/practices/deliver/tool_delivery_pipeline/), which is included in Continuous Delivery, you can achieve continuous delivery in a consistent and reliable way by dividing the software delivery process into stages. The goal is for code to progress through each stage automatically with minimal human intervention. With the [practice of using Delivery Pipelines](https://www.ibm.com/garage/method/practices/deliver/practice_delivery_pipeline/), you can automate the continuous deployment of your project.





 Continuous delivery tutorials 

See the [Learning Lab](https://www.ibm.com/cloud/architecture/courses).





 Continuous delivery courses 

[Get started with agile development and continuous delivery](https://www.ibm.com/cloud/architecture/content/course/get_started_agile_cd).
4. Once changes are validated, the app is deployed to the Production environment.
5. Notifications are sent to Slack to track the deployment activities.







 Before you begin 

This tutorial requires:



* [set up a registry namespace](https://cloud.ibm.com/docs/Registry?topic=Registry-registry_setup_cli_namespaceregistry_namespace_setup)
* and [understand the basics of Kubernetes](https://kubernetes.io/docs/tutorials/kubernetes-basics/).







 Step 1: Create development Kubernetes cluster 

Kubernetes Service delivers powerful tools by combining Docker and Kubernetes technologies, an intuitive user experience, and built-in security and isolation to automate the deployment, operation, scaling, and monitoring of containerized apps in a cluster of compute hosts.

A minimal cluster with one (1) zone, one (1) worker node and the smallest available size (Flavor) is sufficient for this tutorial. The name mycluster will be used in this tutorial.

Open the [Kubernetes clusters](https://cloud.ibm.com/kubernetes/clusters) and click Create cluster. See the documentation referenced below for more details based on the cluster type. Summary:



* Click Standard tier cluster
* For Kubernetes on VPC infrastructure see reference documentation [Creating VPC clusters](https://cloud.ibm.com/docs/containers?topic=containers-cluster-create-vpc-gen2&interface=ui).



* Click Create VPC:



* Enter a name for the VPC.
* Chose the same resource group as the cluster.
* Click Create.



* Attach a Public Gateway to each of the subnets that you create:



* Navigate to the [Virtual private clouds](https://cloud.ibm.com/vpc-ext/network/vpcs).
* Click the previously created VPC used for the cluster.
* Scroll down to subnets section and click a subnet.
* In the Public Gateway section, click Detached to change the state to Attached.
Healthcare use cases for IBM Cloud 

These use cases highlight how workloads on IBM Cloud® Kubernetes Service benefit from the public cloud. They have secure compute on isolated bare metal, easy spin-up of clusters for faster development, migration from virtual machines, and data sharing in cloud databases.



 Healthcare provider migrates workloads from inefficient VMs to Ops-friendly containers for reporting and patient systems 

An IT Exec for a healthcare provider has business reporting and patient systems on-premises. Those systems go through slow enhancement cycles, which leads to stagnant patient service levels.

To improve patient service, the provider looked to IBM Cloud Kubernetes Service and IBM Cloud® Continuous Delivery to reduce IT expenses and accelerate development, all on a secure platform. The provider’s high-use SaaS systems, which held both patient record systems and business report apps, needed updates frequently. Yet the on-premises environment hindered agile development. The provider also wanted to counteract increasing labor costs and a decreasing budget.

They started by containerizing their SaaS systems and putting them in the cloud. From that first step, they went from over-built hardware in a private data center to customizable compute that reduces IT operations, maintenance, and energy. To host the SaaS apps, they easily designed Kubernetes clusters to fit their CPU, RAM, and storage needs. Another factor for decreased staff costs is that IBM manages Kubernetes, so the provider can focus on delivering better customer service.

Accelerated development is a key win for the IT Exec. With the move to public cloud, Developers can experiment easily with Node.js SDK, pushing changes to Development and Test systems, scaled out on separate clusters. Those pushes were automated with open toolchains and IBM Cloud® Continuous Delivery. Updates to the SaaS system no longer languished in slow, error-prone build processes. The Developers can deliver incremental updates to their users, daily or even more frequently. Also, logging and monitoring for the SaaS systems, especially how the patient front-end and back-end reports interact, rapidly integrate into the system. Developers don’t waste time building complex logging systems, just to be able to troubleshoot live systems.
Connecting an IBM Cloud application 

Applications running in IBM Cloud can be bound to your IBM Cloud® Databases for MySQL deployment.



 Connecting a Kubernetes Service application 

Connecting a Cloud databases deployment to a Kubernetes Service application is a two-step process. First, your deployment needs to be bound to your cluster and its connection strings stored in secret. The second step is configuring your application to use the connection strings.

The sample app in the [Connecting a Kubernetes Service Tutorial](https://cloud.ibm.com/docs/databases-for-mysql?topic=cloud-databases-tutorial-k8s-app) provides a sample application that uses Node.js and demonstrates how to bind the sample application to a Cloud Databases deployment.

Before connecting your Kubernetes Service application to a deployment, make sure that the deployment and cluster are both in the same region and resource group.



 Binding your deployment 

Public Endpoints - If you are using the default public service endpoint to connect to your deployment, you can run the cluster service bind command with your cluster name, the resource group, and your deployment name.

ibmcloud ks cluster service bind <your_cluster_name> <resource_group> <your_database_deployment>

Private Endpoints - If you want to use a private endpoint, and one is enabled on your deployment, then first you need to create a service key for your database so Kubernetes can use it when binding to the database.

ibmcloud resource service-key-create <your-private-key> --instance-name <your_database_deployment> --service-endpoint private

The private service endpoint is selected with --service-endpoint private. After that, you bind the database to the Kubernetes cluster through the private endpoint with the cluster service bind command.

ibmcloud ks cluster service bind <your_cluster_name> <resource_group> <your_database_deployment> --key <your-private-key>

Verify - Verify that the Kubernetes secret was created in your cluster namespace. Running the following command, you get the API key for accessing the instance of your deployment that's provisioned in your account.
This tutorial highlights how Cloud Internet Services (CIS), a uniform platform to configure and manage the Domain Name System (DNS), Global Load Balancing (GLB), Web Application Firewall (WAF), and protection against Distributed Denial of Service (DDoS) for internet applications, can be integrated with Kubernetes clusters to support this scenario and to deliver a secure and resilient solution across multiple locations.

Kubernetes service Container Registry

+1

Cloud Internet Services (CIS)



* 2 hours
* 2023-05-10



[Scalable web application on Kubernetes](https://cloud.ibm.com/docs/solution-tutorials?topic=solution-tutorials-scalable-webapp-kubernetes)Scalable web application on Kubernetes

This tutorial walks you through how to run a web application locally in a container, and then deploy it to a Kubernetes cluster created with Kubernetes Service. As an optional step you can build a container image and push the image to a private registry. Additionally, you will learn how to bind a custom subdomain, monitor the health of the environment, and scale the application.

Kubernetes service Container Registry

+1

Secrets Manager



* 2 hours
* 2023-05-05



[Scalable web application on Red Hat OpenShift on IBM Cloud](https://cloud.ibm.com/docs/solution-tutorials?topic=solution-tutorials-scalable-webapp-openshift)Scalable web application on Red Hat OpenShift on IBM Cloud

This tutorial walks you through how to deploy an application to a Red Hat OpenShift on IBM Cloud cluster from a remote Git repository, expose the app on an Red Hat OpenShift on IBM Cloud route, monitor the health of the environment, and scale the application. Additionally, you will learn how to use a private container registry, deploy an application from a private Git repository and bind a custom domain to your application.

Red Hat OpenShift on IBM Cloud Kubernetes service

+1

Container Registry



* 2 hours
* 2023-06-14
Connect a Cloud Databases deployment to an IBM Cloud Kubernetes Service application 

The [Cloud Databases "Hello World" Kubernetes examples](https://github.com/IBM-Cloud/clouddatabases-helloworld-kubernetes-examples) repository holds sample IBM Cloud® applications, which are written in various programming languages, that detail how to connect a Cloud Databases deployment to an IBM Cloud Kubernetes Service application.

Each Git branch of the examples repository corresponds to samples in a particular programming language, either JavaScript that uses Node.js, or python. The files in each folder correspond either to a database or a message queue.



 Trying out the sample applications 

Clone the respective repo you want to use. For instance, you can clone the Node repository by selecting the Node branch. Then, click Clone or download to get the URL you need to clone by using SSH or HTTPS. This command looks like:

git clone -b node git@github.com:IBM-Cloud/clouddatabases-helloworld-kubernetes-examples.git

Or, [clone by using HTTPS](https://docs.github.com/en/github/using-git/which-remote-url-should-i-usecloning-with-https-urls-recommended):

git clone -b node https://github.com/IBM-Cloud/clouddatabases-helloworld-kubernetes-examples.git

After the branch is cloned, select the appropriate directory for the database you want to try. Each database has its own copy of these instructions on how to provision and deploy a database or message queue and an application on IBM Cloud Kubernetes Service.





 Running on IBM Cloud 



1. If you do not already have an IBM Cloud account, [sign up here.](https://cloud.ibm.com/registration/)
2. [Download and install IBM Cloud CLI](https://cloud.ibm.com/docs/cli?topic=cli-install-ibmcloud-cli).
You can use publicly available images from [Docker Hub](https://hub.docker.com/), [public IBM images](https://cloud.ibm.com/docs/Registry?topic=Registry-public_imagespublic_images), or build and manage your own in your private IBM Cloud Container Registry.
3. Add to your Docker image only what is necessary to run the app.
4. Instead of relying on local storage, plan to use persistent storage or cloud database-as-a-service solutions to back up your app's data.
5. Over time, refactor your app processes into microservices.



For more, see the following tutorials.



* [Migrating an app from Cloud Foundry to a cluster](https://cloud.ibm.com/docs/containers?topic=containers-cf_tutorialcf_tutorial).
* [Moving a VM-based app to Kubernetes](https://cloud.ibm.com/docs/solution-tutorials?topic=solution-tutorials-vm-to-containers-and-kubernetes).









 Understanding Kubernetes objects for apps 

With Kubernetes, you declare many types of objects in YAML configuration files such as pods, deployments, and jobs. These objects describe things like what containerized apps are running, what resources they use, and what policies manage their behavior for restarting, updating, replicating, and more. For more information, see the Kubernetes docs for [Configuration best practices](https://kubernetes.io/docs/concepts/configuration/overview/).



 I thought that I needed to put my app in a container. Now what's all this stuff about pods? 

A [pod](https://kubernetes.io/docs/concepts/workloads/pods/) is the smallest deployable unit that Kubernetes can manage. You put your container (or a group of containers) into a pod and use the pod configuration file to tell the pod how to run the container and share resources with other pods.
For more information, see [Solving Business Problems with Splunk on IBM Cloud Kubernetes Service](https://www.ibm.com/cloud/blog/solving-business-problems-with-splunk-on-ibm-cloud-kubernetes-service). Yes Yes 
 Weave Scope [Weave Scope](https://www.weave.works/oss/scope/) provides a visual diagram of your resources within a Kubernetes cluster, including services, pods, containers, processes, nodes, and more. Weave Scope provides interactive metrics for CPU and memory and also provides tools to tail and exec into a container. Yes Yes 







 Security services 

Want a comprehensive view of how to integrate IBM Cloud security services with your cluster? Check out the [Apply end-to-end security to a cloud application tutorial](https://cloud.ibm.com/docs/solution-tutorials?topic=solution-tutorials-cloud-e2e-security).



Table 5. Security services

 Service Description Classic VPC 

 IBM Cloud App ID Add a level of security to your apps with [App ID](https://cloud.ibm.com/docs/appid?topic=appid-getting-started) by requiring users to sign in. To authenticate web or API HTTP/HTTPS requests to your app, you can integrate App ID with your Ingress service by using the [App ID authentication Ingress annotation](https://cloud.ibm.com/docs/containers?topic=containers-comm-ingress-annotationsapp-id-auth). Yes Yes 
 Aqua Security As a supplement to [Vulnerability Advisor](https://cloud.ibm.com/docs/Registry?topic=Registry-va_index), you can use [Aqua Security](https://www.aquasec.com/) to improve the security of container deployments by reducing what your app is allowed to do. For more information, see [Securing container deployments on IBM Cloud with Aqua Security](https://blog.aquasec.com/securing-container-deployments-on-bluemix-with-aqua-security). Yes Yes
Then, you link the trusted profile with as many clusters as you want, based on conditions such as all the prod Kubernetes namespaces in clusters in a resource group. Finally, your pods mount the Kubernetes service account projected volume to get a token that can be exchanged for an IAM token that your apps use to authenticate with the IBM Cloud services.







 Adding IBM Cloud services to clusters 

Use IBM Cloud service binding to automatically create service credentials for your IBM Cloud services and store these credentials in a Kubernetes secret.

Before you begin:



* Ensure you have the following roles:



* [Editor or Administrator IBM Cloud IAM platform access role](https://cloud.ibm.com/docs/openshift?topic=openshift-userschecking-perms) for the cluster where you want to bind a service
* [Writer or Manager IBM Cloud IAM service access role](https://cloud.ibm.com/docs/openshift?topic=openshift-userschecking-perms) for the Red Hat OpenShift project where you want to bind the service
* For Cloud Foundry services: [Developer Cloud Foundry role](https://cloud.ibm.com/docs/account?topic=account-mngcfmngcf) for the space where you want to provision the service



* [Access your Red Hat OpenShift cluster](https://cloud.ibm.com/docs/openshift?topic=openshift-access_cluster).



To add an IBM Cloud service to your cluster:



1. [Create an instance of the IBM Cloud service](https://cloud.ibm.com/docs/account?topic=account-externalappexternalapp).



* Some IBM Cloud services are available only in select regions. You can bind a service to your cluster only if the service is available in the same region as your cluster. In addition, if you want to create a service instance in the Washington DC zone, you must use the CLI.
* For IAM-enabled services: You must create the service instance in the same resource group as your cluster. A service can be created in only one resource group that you can't change afterward.
[Developing Kubernetes-native apps](https://cloud.ibm.com/docs/containers?topic=containers-appapp)



* [Specifying your app requirements in your YAML file](https://cloud.ibm.com/docs/containers?topic=containers-appapp_yaml)



* [Basic deployment metadata](https://cloud.ibm.com/docs/containers?topic=containers-appmetadata)
* [Replica set](https://cloud.ibm.com/docs/containers?topic=containers-appreplicaset)
* [Labels](https://cloud.ibm.com/docs/containers?topic=containers-applabel)
* [Affinity](https://cloud.ibm.com/docs/containers?topic=containers-appaffinity)
* [Container image](https://cloud.ibm.com/docs/containers?topic=containers-appimage)
* [Port for the app's service](https://cloud.ibm.com/docs/containers?topic=containers-appport)
* [Resource requests and limits](https://cloud.ibm.com/docs/containers?topic=containers-appresourcereq)
* [Liveness and readiness probes](https://cloud.ibm.com/docs/containers?topic=containers-appprobe)
* [Pod Disruption Budget](https://cloud.ibm.com/docs/containers?topic=containers-appdisruption-budget)
* [Exposing the app service](https://cloud.ibm.com/docs/containers?topic=containers-appapp-service)
* [Configmaps for container environment variables](https://cloud.ibm.com/docs/containers?topic=containers-appconfigmap)
* [Secrets for container environment variables](https://cloud.ibm.com/docs/containers?topic=containers-appsecret)