post: draft post on quarkus and service binding

Author: iocanel

using-quarkus-with-the-service-binding-operator/readme.org

@@ -0,0 +1,275 @@
+#+BLOG: iocanel.com
+#+ORG2BLOG:
+#+OPTIONS: toc:nil num:nil todo:nil pri:nil tags:nil ^:nil
+#+TITLE: Using Quarkus with the Service Binding Operator
+#+DESCRIPTION: A quick walkthrough on how to use Quarkus with the Service Binding Operator
+#+CATEGORY: Hints, Cloud, Development
+#+TAGS: Java, Quarkus, Kubernetes
+
+* Introduction
+
+  [[https://kubernetes.io][Kubernetes]] is around for almost 7 years now and ever since the beggining there have been efforts to make consuming / binding to services simpler.
+  And while discovering the actual service is not so much of an issue (if you employ a set of conventions), getting the credentials etc is slightly trickier.
+
+  The [[https://svc-cat.io][Service Catalog]] has been an effort that promised to simplify provisioning and binding to services, but it seems that it has lost its momentum. The lack
+  of uniformity between providers, the differences in how each service communicated the binding information and the fact that people tend to favor operators for provisioning services made it pretty hard to use in practice.
+
+  The [[https://github.com/redhat-developer/service-binding-operator][Service Binding Operator]] is a more recent and modern initiative. It stays out of the way of service provisioning (leaving that to operators) and focuses on how to best communicate the binding information to the application.
+  An interesting part of the specification is the [[https://github.com/servicebinding/spec#workload-projection][workload projection]], which defines a directory structure that will be mounted to the application container when the binding happens in order to pass all the required binding information:
+
+  - type
+  - uri
+  - credentials
+
+  Other parts of the specification are related to the `ServiceBinding` resource (which controls what services are bound to which application and how).
+  
+  [[https://quarkus.io/][Quarkus]] already supports the [[https://github.com/servicebinding/spec#workload-projection][workload projection]] part of the spec and recently received enhancments on the binding part, which is going to be the focus of this post.
+  In particular this post is going to discuss how the `ServiceBinding` can be automatically genenerated for the user and will walk you through the whole process from installing the needed operators to configuring and deploying the application.
+
+  For the shake of this post I am going to use [[https://kind.sigs.k8s.io/][kind]] where I am going to install the [[https://github.com/redhat-developer/service-binding-operator][Service Binding Operator]] and the [[https://github.com/CrunchyData/postgres-operator][Crunchy data operator for Postgres]].
+  Then, I am going to create a postgres cluster and finally I am going to use one of the [[https://quarkus.io/][Quarkus]] quickstarts to bind to the provisioned postgres.
+  
+** Start a new kind cluster
+
+   If you've already created one, or don't use [[https://kind.sigs.k8s.io/][kind]] at all, feel free to skip.
+
+   #+begin_src sh
+   kind create cluster
+   #+end_src
+
+** Install the OLM
+
+   Both operators that will be installed in this post, will be installed through the [[https://operatorhub.io][Operatorhub]]. 
+   So, the first step is to install the [[https://olm.operatorframework.io/][Operator Lifecycle Manager]].  
+
+   #+begin_src sh
+     curl -sL https://github.com/operator-framework/operator-lifecycle-manager/releases/download/v0.19.1/install.sh | bash -s v0.19.1
+   #+end_src
+
+** Install the Service Binding Operator
+   
+   #+begin_src sh
+   kubectl create -f https://operatorhub.io/install/service-binding-operator.yaml
+   #+end_src
+
+   To verify the installation execute the following command.
+
+   #+begin_src sh
+     kubectl get csv -n operators
+   #+end_src
+
+   When the `phase` of the [[https://github.com/redhat-developer/service-binding-operator][Service Binding Operator]]  is `Succeeded` you may proceed to the next step.
+   
+** Install the Postgres Crunchy Operator
+
+   #+begin_src sh 
+   kubectl create -f https://operatorhub.io/install/postgresql.yaml
+   #+end_src
+
+   As above to verify the installation execute:
+
+   #+begin_src sh
+     kubectl get csv -n operators
+   #+end_src
+
+   When the `phase` of the operator is `Succeeded` you may proceed to the next step.
+
+
+** Create a Postgres cluster
+
+   We shall create a new namespace, where we will install our cluster and application
+
+   #+begin_src sh 
+     kubectl create ns demo
+     kubectl config set-context --current --namespace=demo
+   #+end_src
+
+
+   To create the cluster we need to apply the following custom resource:
+
+   #+begin_src yaml :tangle ~/pg-cluster.yml
+apiVersion: postgres-operator.crunchydata.com/v1beta1
+kind: PostgresCluster
+metadata:
+  name: pg-cluster
+  namespace: demo
+spec:
+  image: registry.developers.crunchydata.com/crunchydata/crunchy-postgres-ha:centos8-13.4-0
+  postgresVersion: 13
+  instances:
+    - name: instance1
+      dataVolumeClaimSpec:
+        accessModes:
+        - "ReadWriteOnce"
+        resources:
+          requests:
+            storage: 1Gi
+  backups:
+    pgbackrest:
+      image: registry.developers.crunchydata.com/crunchydata/crunchy-pgbackrest:centos8-2.33-2
+      repos:
+      - name: repo1
+        volume:
+          volumeClaimSpec:
+            accessModes:
+            - "ReadWriteOnce"
+            resources:
+              requests:
+                storage: 1Gi
+      - name: repo2
+        volume:
+          volumeClaimSpec:
+            accessModes:
+            - "ReadWriteOnce"
+            resources:
+              requests:
+                storage: 1Gi
+  proxy:
+    pgBouncer:
+      image: registry.developers.crunchydata.com/crunchydata/crunchy-pgbouncer:centos8-1.15-2
+   #+end_src
+
+   This resource has been borrowed from [[https://redhat-developer.github.io/service-binding-operator/userguide/getting-started/quick-start.html][Service Binding Operator Quickstart]], which is definitely something worth looking into (if you haven't already).
+
+   Let's save that file under `pg-cluster.yml` and apply it using `kubectl`
+
+   #+begin_src sh
+   kubectl apply -f ~/pg-cluster.yml
+   #+end_src
+
+   Let's check the pods to verify the installation:
+
+   #+begin_src sh
+   kubectl get pods -n demo
+   #+end_src
+
+** Create a Quarkus application that will bind to Postgres
+
+   Instead of creating an application from scratch, I am going to use one of the [[https://github.com/quarkusio/quarkus-quickstarts.git][Quarkus Quickstarts]].   
+
+*** Grab a quickstart that uses postgres
+
+   The quickstart repository is quite large, So if you don't want to [[clone the repo]] you can just perform a [[sparse checkout]].
+   Both ways are demonstrated below and in both cases the quickstart from `2.3.1.Final` tag should be available under `~/quickstarts/hibernate-orm-panache-quickstart`.
+
+**** clone the repo
+
+     #+begin_src sh
+       git clone --depth 1 --branch 2.3.1.Final [email protected]:quarkusio/quarkus-quickstarts.git ~/quickstarts
+       cd ~/quickstarts/hibernate-orm-panache-quickstart
+     #+end_src
+
+**** sparse checkout
+   
+     #+begin_src sh
+       mkdir ~/quickstarts
+       cd ~/quickstarts
+       git init
+       git config core.sparseCheckout true
+       git remote add origin [email protected]:quarkusio/quarkus-quickstarts.git
+       echo "hibernate-orm-panache-quickstart/" > .git/info/sparse-checkout
+       git pull origin 2.3.1.Final
+       cd hibernate-orm-panache-quickstart
+     #+end_src
+
+
+*** Add the Kubernetes and Service Binding extensions
+
+    #+begin_src sh :dir  ~/quickstarts/hibernate-orm-panache-quickstart/
+      quarkus ext add -B kubernetes
+      quarkus ext add -B kubernetes-service-binding
+      quarkus ext add -B container-image-docker
+    #+end_src
+
+***  Bind to the target Postgres cluster
+
+    In order to bind the postgres service to our application we need to either provide a `ServiceBidning` resource or have it generated.
+    To have the binding generated for us we need to provide the service coordinates:
+   
+    - apiVersion: `postgres-operator.crunchydata.com/v1beta1`
+    - kind: `PostgresCluster`
+    - name: `pg-cluster`
+
+      prefixed with `quarkus.kubernetes-service-binding.services.<id>.` as shown below:
+
+    #+begin_src sh
+      echo "quarkus.kubernetes-service-binding.services.my-db.api-version=postgres-operator.crunchydata.com/v1beta1
+      quarkus.kubernetes-service-binding.services.my-db.kind=PostgresCluster
+      quarkus.kubernetes-service-binding.services.my-db.name=pg-cluster" >> ~/quickstarts/hibernate-orm-panache-quickstart/src/main/resources/application.properties
+    #+end_src
+
+    *Note*: The <id> can be anything at this point. It's only used for correlating the service coordinates.
+
+*** Switch the latest Quarkus version
+
+    Generation of the Service Binding resource is not available in `2.3.1.Final` so we are going to switch to a snapshot version.
+    This means that you need to checkout and build quarkus from latest `main`.
+    This post assumes you have already done so and skips directly to the next step, which is switching to the snapshot version:
+
+     #+begin_src sh :dir ~/quickstarts/hibernate-orm-panache-quickstart
+      sed -i "s|2.3.1.Final|999-SNAPSHOT|g" pom.xml
+    #+end_src
+
+*** Prepare for deployment
+
+    To deploy, we need to perform a container image build, load the image to our cluster (remember we are using [[https://kind.sigs.k8s.io/][kind]]), generate the resource and perform the deployment.
+   
+**** Build the container image
+
+     To build the container image, you can use:
+    
+     #+begin_src sh :dir ~/quickstarts/hibernate-orm-panache-quickstart
+       mvn clean install -Dquarkus.container-image.build=true -DskipTests 
+     #+end_src
+
+     This assumes that you have docker up and running.
+
+**** Load the docker image to the cluster
+
+     #+begin_src sh
+     kind load docker-image iocanel/hibernate-orm-panache-quickstart:1.0.0-SNAPSHOT
+     #+end_src
+
+***** Loading the image on minikube     
+     
+      If you are using [[https://minikube.sigs.k8s.io/docs/start/][minikube]] instead, then execute:
+       #+begin_src sh
+     eval $(minikube docker-env)
+     #+end_src
+
+      and re-build the image.
+
+     When using tools like [[https://kind.sigs.k8s.io/][kind]] or [[https://minikube.sigs.k8s.io/docs/start/][minikube]], it is generally a good idea to change the image pull policy to `IfNotPresent` to avoid uneeded pulls, since most of the time the image will be loaded from the local docker daemon, as shown above.
+     To set the image pull policy:
+     
+    #+begin_src sh
+      echo "quarkus.kubernetes.image-pull-policy=IfNotPresent" >> ~/quickstarts/hibernate-orm-panache-quickstart/src/main/resources/application.properties
+    #+end_src
+
+**** Deploy the application
+
+     The next step will generate the deployment manifest, including the `ServiceBinding` and will apply them on kubernetes.
+     
+     #+begin_src sh :dir ~/quickstarts/hibernate-orm-panache-quickstart
+       mvn clean install -Dquarkus.kubernetes.deploy=true -DskipTests 
+     #+end_src
+
+
+**** Verify the installation
+
+     #+begin_src sh
+       kubectl port-forward service/hibernate-orm-panache-quickstart 8080:80
+     #+end_src
+
+     Open your browser on [[http://localhost:8080]] and enjoy!
+
+* Thoughs and future steps     
+
+  I am really excited with the progress on the Service binding front. Thinks are looking great and can look even better.
+  Some potential improvements I can see coming in the near future, is reducing the amount of needed configuration, with the use of smart conventions (e.g. assuming that custom resource name is the same as the database name unless explicitly specified) and a reasonable set of defaults (e.g. assuming that for postgres the default operator is [[https://github.com/CrunchyData/postgres-operator][CrunchyData operator]]).
+  This could even allow us to bind to services with zero config, without really sacrificing in flexibility and customizability!
+
+  I hope I could get you even half as excited as I am!
+
+   
+