이 콘텐츠는 선택한 언어로 제공되지 않습니다.
Chapter 1. Service binding
The following chapter provides information about service binding and workload projection that were added to Red Hat build of Quarkus in version 2.7.5 and are in the state of Technology Preview in version 2.13.
Generally, OpenShift applications and services, also referred to as deployable workloads, need to be connected to other services for retrieving additional information, such as service URLs or credentials.
The Service Binding Operator manages the required communication for obtaining this information. This Operator then determines the following:
- How a service consumer intends to bind to such a service
-
The tools for application and service binding, such as the
quarkus-kubernetes-service-bindingextension
Quarkus supports the Service Binding Specification for Kubernetes to bind services to applications.
Specifically, Quarkus implements the Workload Projection part of the specification, allowing applications to bind to services, such as a Database or a Broker, without the need for user configuration.
To enable service binding for the available extensions, add the quarkus-kubernetes-service-binding extension to the application dependencies.
You can use the following extensions for service binding and for workload projection:
-
quarkus-jdbc-mariadb -
quarkus-jdbc-mssql -
quarkus-jdbc-mysql -
quarkus-jdbc-postgresql -
quarkus-mongo-client- Technology Preview -
quarkus-kafka-client -
quarkus-smallrye-reactive-messaging-kafka
-
quarkus-reactive-mssql-client- Technology Preview -
quarkus-reactive-mysql-client -
quarkus-reactive-pg-client
-
1.1. Workload projection 링크 복사링크가 클립보드에 복사되었습니다!
Workload projection is a process of obtaining the configuration for services from the Kubernetes cluster. This configuration takes the form of directory structures that follow certain conventions and is attached to an application or to a service as a mounted volume. The kubernetes-service-binding extension uses this directory structure to create configuration sources, which allows you to configure additional modules, such as databases or message brokers.
You can use workload projection during application development to connect their application to a development database or other locally-run services without changing the actual application code or configuration.
For an example of a workload projection where the directory structure is included in the test resources and passed to integration test, see the Kubernetes Service Binding datasource GitHub repository.
-
The
k8s-sbdirectory is the root of all service bindings. In this example, only one database calledfruit-dbis intended to be bound. This binding database has thetypefile, that indicatespostgresqlas the database type, while the other files in the directory provide the necessary information to establish the connection. -
After your Quarkus project obtains information from
SERVICE_BINDING_ROOTenvironment variables that are set by OpenShift Container Platform, you can locate generated configuration files that are present in the file system and use them to map the configuration-file values to properties of certain extensions.
1.2. Introduction to Service Binding Operator 링크 복사링크가 클립보드에 복사되었습니다!
The Service Binding Operator is an Operator that implements Service Binding Specification for Kubernetes and is meant to simplify the binding of services to an application. Containerized applications that support Workload Projection obtain service binding information in the form of volume mounts. The Service Binding Operator reads binding service information and mounts it to the application containers that need it.
The correlation between application and bound services is expressed through the ServiceBinding resources, which declares the intent of what services are meant to be bound to what application.
The Service Binding Operator watches for ServiceBinding resources, which inform the Operator what applications are meant to be bound with what services. When a listed application is deployed, the Service Binding Operator collects all the binding information that must be passed to the application, then upgrades the application container by attaching a volume mount with the binding information.
The Service Binding Operator completes the following actions:
-
Observes
ServiceBindingresources for workloads intended to be bound to a particular service - Applies the binding information to the workload using volume mounts
The following chapter describes the automatic and semi-automatic service binding approaches and their use cases. With either approach, the kubernetes-service-binding extension generates a ServiceBinding resource. With the semi-automatic approach, users must provide a configuration for target services manually. With the automatic approach, for a limited set of services generating the ServiceBinding resource, no additional configuration is needed.
1.3. Semi-automatic service binding 링크 복사링크가 클립보드에 복사되었습니다!
A service binding process starts with a user specification of required services that will be bound to a certain application. This expression is summarized in the ServiceBinding resource that is generated by the kubernetes-service-binding extension. The use of the kubernetes-service-binding extensions helps users to generate ServiceBinding resources with minimal configuration, therefore simplifying the process overall.
The Service Binding Operator responsible for the binding process then reads the information from the ServiceBinding resource and mounts the required files to a container accordingly.
An example of the
ServiceBindingresource:Copy to Clipboard Copied! Toggle word wrap Toggle overflow NoteThe
quarkus-kubernetes-service-bindingextension provides a more compact way of expressing the same information. For example:quarkus.kubernetes-service-binding.services.db-demo.api-version=postgres-operator.crunchydata.com/v1beta1 quarkus.kubernetes-service-binding.services.db-demo.kind=Database
quarkus.kubernetes-service-binding.services.db-demo.api-version=postgres-operator.crunchydata.com/v1beta1 quarkus.kubernetes-service-binding.services.db-demo.kind=DatabaseCopy to Clipboard Copied! Toggle word wrap Toggle overflow
After adding the earlier configuration properties inside your application.properties, the quarkus-kubernetes, in combination with the quarkus-kubernetes-service-binding extension, automatically generates the ServiceBinding resource.
The earlier mentioned db-demo property-configuration identifier now has a double role and also completes the following actions:
-
Correlates and groups
api-versionandkindproperties together. Defines the
nameproperty for the custom resource, which you can edit later if needed. For example:quarkus.kubernetes-service-binding.services.db-demo.api-version=postgres-operator.crunchydata.com/v1beta1 quarkus.kubernetes-service-binding.services.db-demo.kind=Database quarkus.kubernetes-service-binding.services.db-demo.name=my-db
quarkus.kubernetes-service-binding.services.db-demo.api-version=postgres-operator.crunchydata.com/v1beta1 quarkus.kubernetes-service-binding.services.db-demo.kind=Database quarkus.kubernetes-service-binding.services.db-demo.name=my-dbCopy to Clipboard Copied! Toggle word wrap Toggle overflow
1.4. Generating a ServiceBinding custom resource by using the semi-automatic method 링크 복사링크가 클립보드에 복사되었습니다!
You can generate a ServiceBinding resource semi-automatically. The following procedure shows the OpenShift Container Platform deployment process, including how to install operators to configure and deploy an application.
With the following procedure, you install Service Binding Operator and the PostgreSQL Operator from Crunchy Data.
PostgreSQL Operator is a third-party component. For PostgreSQL Operator support policies and terms of use, contact the software vendor Crunchy Data.
Then, the procedure creates a PostgreSQL cluster, a simple application, and finally, deploys it and binds it to the provisioned cluster.
Prerequisites
- You have created an OpenShift Container Platform 4.10 cluster
- You have access to OperatorHub and OpenShift Container Platform Administrator privileges needed to install cluster-wide Operators from OperatorHub
You have installed:
-
ocorchestration tool - Maven and Java
-
Procedure
The steps in the following procedure use the HOME (~) directory as a saving and installation destination.
Install the Service Binding Operator version 1.0 and higher using the Installing the Service Binding Operator from the OpenShift Container Platform web UI procedure.
Verify the installation:
oc get csv -n openshift-operators -w
oc get csv -n openshift-operators -wCopy to Clipboard Copied! Toggle word wrap Toggle overflow -
When the
phaseof the Service Binding Operator is set toSucceeded, proceed to the next step.
-
When the
Install the Crunchy PostgreSQL Operator from OperatorHub by using the web console or CLI. For links to instructions, see the Deploy & use section.
Verify the installation:
oc get csv -n openshift-operators -w
oc get csv -n openshift-operators -wCopy to Clipboard Copied! Toggle word wrap Toggle overflow -
When the
phaseof the operator is set toSucceeded, proceed to the next step.
-
When the
Create a PostgreSQL cluster:
Create a new OpenShift Container Platform namespace, in the space of which you will create a cluster and deploy your application later on. Throughout this procedure, the namespace is called
demo.oc new-project demo
oc new-project demoCopy to Clipboard Copied! Toggle word wrap Toggle overflow Create the following custom resource and save it as
pg-cluster.yml:Copy to Clipboard Copied! Toggle word wrap Toggle overflow NoteThis YAML has been reused from Service Binding Operator Quickstart.
Apply the created custom resource:
oc apply -f ~/pg-cluster.yml
oc apply -f ~/pg-cluster.ymlCopy to Clipboard Copied! Toggle word wrap Toggle overflow NoteThis command assumes that you saved the
pg-cluster.ymlfile in HOME.Check the Pods to verify the installation:
oc get pods -n demo
oc get pods -n demoCopy to Clipboard Copied! Toggle word wrap Toggle overflow -
Wait for the Pods to get into the
READYstate, which signals the installation is complete.
-
Wait for the Pods to get into the
Create a Quarkus application that binds to the PostgreSQL database.
The application we are going to create is going to be a simple
todoapplication that will connect to PostgreSQL by using hibernate and panache.Generate the application:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow Add all required extensions for connecting to PostgreSQL, generating all required resources, and building a container image for our application:
./mvnw quarkus:add-extension -Dextensions="resteasy-reactive-jackson,jdbc-postgresql,hibernate-orm-panache,openshift,kubernetes-service-binding"
./mvnw quarkus:add-extension -Dextensions="resteasy-reactive-jackson,jdbc-postgresql,hibernate-orm-panache,openshift,kubernetes-service-binding"Copy to Clipboard Copied! Toggle word wrap Toggle overflow Create a simple entity, as outlined in the following example:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow Expose the entity:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow
Bind to the target PostgreSQL cluster by generating a
ServiceBindingresource.Provide the service coordinates to generate the binding and configure the data source:
-
apiVersion:
postgres-operator.crunchydata.com/v1beta1 -
kind:
PostgresCluster name:
pg-clusterThis is done by setting a
quarkus.kubernetes-service-binding.services.<id>.prefix as in the example below. Theidis used to group properties together and can be anything.Copy to Clipboard Copied! Toggle word wrap Toggle overflow
-
apiVersion:
Create an
import.sqlscript with some initial data:INSERT INTO todo(id, title, completed) VALUES (nextval('hibernate_sequence'), 'Finish the blog post', false);INSERT INTO todo(id, title, completed) VALUES (nextval('hibernate_sequence'), 'Finish the blog post', false);Copy to Clipboard Copied! Toggle word wrap Toggle overflow
Deploy the application, including
ServiceBinding, and apply it to the cluster:mvn clean install -Dquarkus.kubernetes.deploy=true -DskipTests
mvn clean install -Dquarkus.kubernetes.deploy=true -DskipTestsCopy to Clipboard Copied! Toggle word wrap Toggle overflow - Wait for the deployment to finish.
Verification
Verify the deployment:
oc get pods -n demo -w
oc get pods -n demo -wCopy to Clipboard Copied! Toggle word wrap Toggle overflow Verify the installation
Port forward to http port locally and access the
/todoendpoint:oc port-forward service/todo-example 8080:80
oc port-forward service/todo-example 8080:80Copy to Clipboard Copied! Toggle word wrap Toggle overflow Open the following URL in a browser:
http://localhost:8080/todo
http://localhost:8080/todoCopy to Clipboard Copied! Toggle word wrap Toggle overflow
1.5. Automatic service binding 링크 복사링크가 클립보드에 복사되었습니다!
The quarkus-kubernetes-service-binding extension can generate the ServiceBinding resource automatically after detecting that an application requires access to the external services that are provided by available bindable Operators.
Automatic service binding can be generated for a limited number of service types. To be consistent with established terminology for Kubernetes and Quarkus services, this chapter refers to these service types as kinds.
| Service binding type | Operator | Api version | Kind |
|
| postgres-operator.crunchydata.com/v1beta1 | PostgresCluster | |
|
| pxc.percona.com/v1-9-0 | PerconaXtraDBCluster | |
|
| psmdb.percona.com/v1-9-0 | PerconaServerMongoDB |
- Red Hat build of Quarkus 2.13 support for MongoDB Operator is provided as a Technology Preview and applies to the client only.
- See the Quarkus application configurator page for a list of supported Panache extensions in Red Hat build of Quarkus 2.13.
1.5.1. Automatic datasource binding 링크 복사링크가 클립보드에 복사되었습니다!
For traditional databases, automatic binding is initiated whenever a datasource is configured as follows:
quarkus.datasource.db-kind=postgresql
quarkus.datasource.db-kind=postgresql
The previous configuration, combined with the presence of quarkus-datasource, quarkus-jdbc-postgresql, quarkus-kubernetes, and quarkus-kubernetes-service-binding properties in the application, results in the generation of the ServiceBinding resource for the postgresql database type.
By using the apiVersion and kind properties of the Operator resource, which matches the used postgresql Operator, the generated ServiceBinding resource binds the service or resource to the application.
When you do not specify a name for your database service, the value of the db-kind property is used as the default name.
services: - apiVersion: postgres-operator.crunchydata.com/v1beta1 kind: PostgresCluster name: postgresql
services:
- apiVersion: postgres-operator.crunchydata.com/v1beta1
kind: PostgresCluster
name: postgresql
Specified the name of the datasource as follows:
quarkus.datasource.fruits-db.db-kind=postgresql
quarkus.datasource.fruits-db.db-kind=postgresql
The service in the generated ServiceBinding then displays as follows:
services: - apiVersion: postgres-operator.crunchydata.com/v1beta1 kind: PostgresCluster name: fruits-db
services:
- apiVersion: postgres-operator.crunchydata.com/v1beta1
kind: PostgresCluster
name: fruits-db
Similarly, if you use mysql, the name of the datasource can be specified as follows:
quarkus.datasource.fruits-db.db-kind=mysql
quarkus.datasource.fruits-db.db-kind=mysql
The generated service contains the following:
services: - apiVersion: pxc.percona.com/v1-9-0 kind: PerconaXtraDBCluster name: fruits-db
services:
- apiVersion: pxc.percona.com/v1-9-0
kind: PerconaXtraDBCluster
name: fruits-db
1.5.1.1. Customizing automatic service binding 링크 복사링크가 클립보드에 복사되었습니다!
While the automatic service binding feature was developed to eliminate as much of the manual configuration as possible, there are scenarios where you might need to manually modify the generated ServiceBinding resource. The generation process exclusively relies on information extracted from the application and the knowledge of the supported Operators, which may not reflect what is deployed in the cluster. The generated resource is based purely on the knowledge of the supported bind-able operators for popular service kinds and a set of conventions that were developed to prevent possible mismatches, such as:
- The target resource name does not match the datasource name
- A specific Operator needs to be used rather than the default Operator for that service kind
- Version conflicts that occur when a user needs to use any other version than default or latest
Conventions
- The target resource coordinates are determined based on the type of Operator and the kind of service.
-
The target resource name is set by default to match the service kind, such as
postgresql,mysql,mongo. - For named datasources, the name of the datasource is used.
-
For named
mongoclients, the name of the client is used.
Example 1: Name mismatch
For cases in which you need to modify the generated ServiceBinding to fix a name mismatch, use the quarkus.kubernetes-service-binding.services properties and specify the service’s name as the service key.
The service key is usually the name of the service, for example, the name of the datasource, or the name of the mongo client. When this value is not available, the datasource type, such as postgresql, mysql, mongo, is used instead.
To avoid naming conflicts between different types of services, prefix the service key with a specific datasource type, such as postgresql-<person>.
The following example shows how to customize the apiVersion property of the PostgresCluster resource:
quarkus.datasource.db-kind=postgresql quarkus.kubernetes-service-binding.services.postgresql.api-version=postgres-operator.crunchydata.com/v1beta2
quarkus.datasource.db-kind=postgresql
quarkus.kubernetes-service-binding.services.postgresql.api-version=postgres-operator.crunchydata.com/v1beta2
Example 2: Application of a custom name for a datasource
In Example 1, the db-kind(postgresql) was used as a service key. In this example, because the datasource is named, according to convention, the datasource name (fruits-db) is used instead.
The following example shows that for a named datasource, the datasource name is used as the name of the target resource:
quarkus.datasource.fruits-db.db-kind=postgresql
quarkus.datasource.fruits-db.db-kind=postgresql
This has the same effect as the following configuration:
quarkus.kubernetes-service-binding.services.fruits-db.api-version=postgres-operator.crunchydata.com/v1beta1 quarkus.kubernetes-service-binding.services.fruits-db.kind=PostgresCluster quarkus.kubernetes-service-binding.services.fruits-db.name=fruits-db
quarkus.kubernetes-service-binding.services.fruits-db.api-version=postgres-operator.crunchydata.com/v1beta1
quarkus.kubernetes-service-binding.services.fruits-db.kind=PostgresCluster
quarkus.kubernetes-service-binding.services.fruits-db.name=fruits-db
Revised on 2024-04-16 11:36:03 UTC