In one of my past articles, we’ve learned how to deploy the Spring Boot Kotlin application to the Google Kubernetes Engine. According to your feedback, you really enjoyed it and some of you asked me to write something more about connecting to the databases in such an environment.

In the beginning, I’d like to thank you so much for the inspiration. You can be sure, that in the future I will prepare more articles on this topic.

In this guide, I’d like to show you how to deploy Spring Boot Kotlin application to the GKE with Cloud SQL using a sidecar pattern. It will be the continuation of this post, so I highly recommend spending some time checking it.

2. Create Cloud SQL Instance

As the first step, let’s head to the GCP Cloud SQL console and click the Create Instance button.

On the next page, let’s select the MySQL database:

Let’s provide the instance ID and root password for our database. As you can see on the below screenshot, we can also specify other things, like region, zone, or database version:

Finally, let’s click the Create button and start the process of creating the instance.

3. Create a Service Account

As the next step, let’s switch to the service accounts panel of the IAM management. We need to prepare the service account, which will be used later to establish the connection between the GKE and Cloud SQL.

Let’s click the Create Service Account button. Then, let’s specify the service account name and click Create:

Nextly, let’s grant the Cloud SQL Admin Role to our service account:

Please note: for the tutorial, we are using the admin role, but in the real-life scenarios we should always remember about the Principle of Least Privilege (POLP).

4. Enable Cloud SQL Admin API

Before we will be able to connect using the Cloud SQL Proxy, we need to enable the Cloud SQL Admin API. To do that, let’s head to the API management page and click the Enable button:

5. Connecting Using the Cloud SQL Proxy

There are a few approaches on how to connect to our SQL instance. For a better understanding of the topic, I highly recommend checking out this Google guide.

In this tutorial, we will add the proxy to our application’s pod using the sidecar container pattern. If you would be interested in tutorials covering other ways of connection, please let me know about it.

5.1. Add Proxy Container

Let’s start by adding the proxy to the deployment file. Let’s head to the previously created deployment.yaml file and put the following config under the containers:

- image: gcr.io/cloudsql-docker/gce-proxy:1.18.0
  name: cloud-sql-proxy
  command:
    - "/cloud_sql_proxy"
    - "-instances=<PROJECT_ID>:<ZONE>:<INSTANCE_NAME>=tcp:3306"
  securityContext:
    runAsNonRoot: true

The second command in our configuration requires us to specify the list of comma-separated fully qualified instances connections names. You can check your connection name in the Cloud SQL console.

5.2. Connect Service Account

As the next step, we will provide the service account for our proxy. We will do it using GKE’s Workload Identity feature, which is the preferred method. To put it simply, we will bind the Kubernetes Service Account (KSA) to a Google Service Account (GSA).

Let’s start by enabling the Workload Identity on our existing cluster:

gcloud container clusters update  \
  --workload-pool=<PROJECT-ID>.svc.id.goog
  --zone=<ZONE>

We will need to wait for some time for the changes to be applied.

Nextly, let’s create the service-account.yaml file and put there the configuration for the KSA:

apiVersion: v1
kind: ServiceAccount
metadata:
  name: cloud-sql-sa

And create the KSA in our cluster:

kubectl apply -f service-account.yaml

With that being done, we can enable the IAM binding between the <GSA-NAME> and <KSA-NAME>:

gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:<PROJECT-ID>.svc.id.goog[<K8S-NAMESPACE>/<KSA-NAME>]" \
  <GSA-NAME>@<PROJECT-ID>.iam.gserviceaccount.com

As the next step, let’s add an annotation to <KSA-NAME> to complete the binding:

kubectl annotate serviceaccount \
   <KSA-NAME> \
   iam.gke.io/gcp-service-account=<GSA-NAME>@<PROJECT-ID>.iam.gserviceaccount.com

Finally, please make sure to specify the service account for the Kubernetes object:

spec:
  serviceAccountName: cloud-sql-sa

6. Configure Spring Boot App

After all the above steps, we can finally switch to our Spring Boot project to set up the connection.

6.1. Imports

Let’s start by adding necessary imports:

    runtimeOnly("mysql:mysql-connector-java")

As you can see, we are adding MySQL Connector dependency. If we had chosen another database in step 2, we would have to import the appropriate driver here.

6.2. Edit Application Properties

As the next step, let’s edit the application.yaml file and put the following configuration there:

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/${DB_NAME}
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}

Please notice, that the environment variables should be set to, or replaced with the correct values. For the learning purposes, as the user, we can use root with the password we’ve set in step 2. Also, to create the database, we can head to the Cloud SQL Databases console.

7. Deploy Spring Boot App to GKE

As the last step, let’s deploy our application to the Google Kubernetes Engine. Let’s build and push our container with the following commands:

docker build -t spring-boot-example .
docker tag spring-boot-example gcr.io//spring-boot-example:0.0.2
docker push gcr.io//spring-boot-example:0.0.2

Please notice, that you can use the tag whatever you like. I’m just using 0.0.2 to keep it concise with the previous article.

Finally, let’s update our deployment file:

containers:
  - image: gcr.io//spring-boot-example:0.0.2

And submit our changes to the cluster:

kubectl apply -f deployment.yaml

After all, we can check the status of changes, for instance with the get pods command:

kubectl get pods

//example response
NAME                                   READY   STATUS    RESTARTS   AGE
spring-boot-example-799bb5dd97-whwdb   2/2     Running   0          55s

As you can see, the Pod is running and both containers are ready.

8. Summary

And that would be all for this article. We’ve covered step by step how to deploy the Spring Boot application to the Google Kubernetes Engine with Cloud SQL. I believe, that some of the steps may seem pretty difficult, but I can guarantee you that over time, you will get a much better understanding of this topic.

Hope you had a great time reading this article. Please remember, that you can always contact me through the fan page, group, or contact form. Don’t be afraid to ask any questions- I will be more than happy to answer them.

And of course, you can find the full source code here.

The post Spring Boot on Google GKE with Cloud SQL and Kotlin appeared first on Codersee blog- Kotlin on the backend.

Google Cloud Pub/Sub might be a great tool to integrate decoupled systems hosted on GCP as well as elsewhere on the Internet. In this step-by-step guide, we will learn how to set up Google Cloud Pub/Sub with Spring Boot Java application.

Moreover, I will show you how to configure it for serialization and deserialization of POJOs using Jackson JSON.

2. Setup Google Cloud Project

2.1. Create Topic and Subscription

As the first step, let’s go to the GCP console, and let’s enable the Pub/Sub API for our future Spring Boot project by clicking the Enable button.

Alternatively, we can do the same with a gcloud CLI command:

gcloud services enable pubsub.googleapis.com

As the next step, let’s go to the Topics tab in the left sidebar and create a new topic named example:

Or again, with a gcloud command:

gcloud pubsub topics create example

Nextly, let’s go to the Subscriptions tab and click the create subscription button.

On this page, we can specify the subscription ID. Let’s call it an example-subscription and choose our previously created topic:

Or, as usual, it can be done using CLI command:

gcloud pubsub subscriptions create example-subscription --topic=example

If we would like to validate whether everything has been created, we can check it with these two commands:

gcloud pubsub subscriptions describe example-subscription
gcloud pubsub topics describe example

2.2. Setup Service Account

In this paragraph, we will learn how to create a service account, which will be used later in our Spring Boot project.

As the first step, let’s go to the GCP IAM & Admin console and select the Service Accounts tab. Then, let’s click the create service account button and specify the name as follows:

Nextly, we need to click continue, and on the next page, let’s add Pub/Sub Admin role:

After the role has been added, we need to click next and finally click done. We will be redirected to the page showing all service accounts in our project. Let’s click the three dots near to the recently created Pub/Sub service account and click Create key:

As the key type, let’s select the JSON:

As the last step, please download the file and put it inside the resources directory of the Spring Boot project.

3. Imports

If all the Pub/Sub steps above have been completed, we can switch to the Spring Boot project. Firstly, let’s import two dependencies we will need for our project to work:

  
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.cloud:spring-cloud-gcp-starter-pubsub'

4. Configure Application Properties

As the next step, let’s define the application.yaml file as follows:

 
pubsub-example:
  subscription:
    name: ${EXAMPLE_PUBSUB_SUBSCRIPTION}
  topic:
    name: ${EXAMPLE_PUBSUB_TOPIC}

spring:
  cloud:
    gcp:
      credentials:
        location: classpath:credentials.json

Please notice, the name of the JSON should match the name of the file that we’ve put inside the resources folder. Also, the environment variables describing subscription and topic should be set to the correct values, for example:

• EXAMPLE_PUBSUB_SUBSCRIPTION -> projects/[PROJECT-ID]/subscriptions/example-subscription
• EXAMPLE_PUBSUB_TOPIC -> projects/[PROJECT-ID]/topics/example

6. Create a POJO Class

Our next step is to create a simple POJO class, which will be used for the serialization and deserialization of the messages sent through the Pub/Sub:

  
public class MessageEntity {

    private final LocalDateTime timestamp;
    private final String message;
    
    //constructor, getters, setters
}

As you can see, it is a simple class containing the timestamp and the value of the message.

7. Set Up The Consumer

Let’s start the work on the consumer part by creating the PubSubConsumer interface:

  
public interface PubSubConsumer {

    String subscription();

    Class payloadType();

    Consumer<ConvertedBasicAcknowledgeablePubsubMessage> messageConsumer();
}

As you can see, this interface consists of three methods definitions:

• subscription -> returns the name of the subscription
• payloadTyme -> returns the Class object representing the target type of the payload
• messageConsumer -> returns the callback method triggered when new messages arrive

Technically, we don’t need this interface, but with this approach, we will be able to add easily more consumers in the future.

Secondly, let’s create the ExampleCosumer class implementing the interface:

  
@Component
public class ExampleConsumer implements PubSubConsumer {

    private static final Logger log = LoggerFactory.getLogger(ExampleConsumer.class);
    private final String subscriptionName;

    public ExampleConsumer(
        @Value("${pubsub-example.subscription.name}") String subscriptionName
    ) {
        this.subscriptionName = subscriptionName;
    }
}

As you might have noticed, our class contains two fields: a logger and a subscriptionName which will be bound with the value from our properties.yaml file.

Please remember, that our class implements PubSubConsumer, so as the next step we need to provide the definition for each method:

  
@Override
public String subscription() {
    return subscriptionName;
}

@Override
public Class payloadType() {
    return MessageEntity.class;
}

@Override
public Consumer<ConvertedBasicAcknowledgeablePubsubMessage> messageConsumer() {
    return this::consume;
}

To keep our code more readable, let’s implement our consumer method as a separate function:

  
private void consume(ConvertedBasicAcknowledgeablePubsubMessage message) {
    MessageEntity received = message.getPayload();

    log.info(
        "Received entity: [timestamp= {}, message= {}]",
        received.getTimestamp(),
        received.getMessage()
    );

    message.ack();
}

To put it simply, this method extracts the payload from the ConvertedBasicAcknowledgeablePubsubMessage object and logs the timestamp and the message at the INFO level. In the end, it asynchronously acknowledges the message.

As the next step, let’s create ExampleSubscriberConfig class and put the configuration for our subscriber there:

  
@Configuration
public class ExampleSubscriberConfig {

    private static final Logger log = LoggerFactory.getLogger(ExampleSubscriberConfig.class);

    private final PubSubTemplate pubSubTemplate;
    private final PubSubConsumer exampleConsumer;

   //constructor
}

As you might have noticed, besides the logger and the exampleConsumer, we are injecting pubsubTemplate, which will be used for publishing to topics and consuming messages.

Let’s implement the method responsible for subscription:

  
@EventListener(ApplicationReadyEvent.class)
public void subscribe() {
    log.info("Subscribing to {}", exampleConsumer.subscription());

    pubSubTemplate.subscribeAndConvert(
        exampleConsumer.subscription(),
        exampleConsumer.messageConsumer(),
        exampleConsumer.payloadType()
    );
}

The annotation  EventListener used with ApplicationReadyEvent indicates, that the method will be called when the application is ready to receive requests.

As the last step, we need to provide the bean definition for a converter using Jackson JSON:

  
@Configuration
public class PubSubConfig {

    @Bean
    public JacksonPubSubMessageConverter jacksonPubSubMessageConverter(ObjectMapper objectMapper) {
        return new JacksonPubSubMessageConverter(objectMapper);
    }
}

With that being done, we are ready to receive the messages.

8. Set Up The Publisher

Besides receiving the messages, it would be good to have the possibility to publish some. Let’s start the work on the publisher part by creating the ExamplePublisher class:

  
@Component
public class ExamplePublisher {

    private final String topic;
    private final PubSubTemplate pubSubTemplate;

    public ExamplePublisher(
        @Value("${pubsub-example.topic.name}") String topic,
        PubSubTemplate pubSubTemplate) {
        this.topic = topic;
        this.pubSubTemplate = pubSubTemplate;
    }
}

As we can see, we need to inject the PubSubTemplate bean and the topic, which will be set to the value from the application properties.

Let’s add a publish method then. It will take the MessageEntity as the argument:

  
public void publish(MessageEntity payload) {
    pubSubTemplate.publish(topic, payload);
}

As you might have noticed, this method uses the publish method to push the object to the specified Pub/Sub topic.

9. Create Example Controller

And finally, we can implement the TestController class:

  
@RestController
@RequestMapping("/api")
public class TestController {

    private final ExamplePublisher publisher;

    public TestController(ExamplePublisher publisher) {
        this.publisher = publisher;
    }

    @PostMapping("/topic")
    public void publish(@RequestBody String message) {
        MessageEntity entity = new MessageEntity(LocalDateTime.now(), message);
        publisher.publish(entity);
    }
}

It’s just a simple REST controller, which will be responding to the POST /api/topic calls and forwarding the message to the publisher.

10. Testing Using Curl

Lastly, there is nothing else to do than just test our application with the following command:

  
curl -d 'Some message' localhost:8080/api/topic

After it executes, we should see a new entry in our application logs (and each time we call the endpoint as well).

9. GCP Pub/Sub With Spring Boot Conclusion

And I believe, that’s all for today. In this step-by-step tutorial, we’ve learned how to publish and receive messages through the Google Cloud Pub/Sub using the Spring Boot Java application.

I hope that you’ve really enjoyed this guide. I would be forever grateful if you would like to share some feedback with me. Would you like to see more Java tutorials as well? Please, let me know about it using our page, group, or contact form.

For the source code of the project, please visit our project on GitHub.

The post Google Cloud Pub/Sub with Spring Boot and Java appeared first on Codersee blog- Kotlin on the backend.

If you’ve been learning programming for some time you probably heard about Kubernetes (also known as Kube or K8s). In simple words, Kubernetes is a system for automating loads of processes, like deployment, scaling, and management of containerized applications.

There is no doubt that the K8s can improve our productivity and make our application more stable. However, maintaining the whole system might become more difficult and time-consuming. Fortunately, we can find lots of cloud providers offering Kubernetes as a managed service, like:

• Google Kubernetes Engine (GKE),
• Azure Kubernetes Service (AKS),
• Amazon Elastic Container Service for Kubernetes (Amazon EKS)

Choosing a provider-managed solution transfers the responsibility for managing and provisioning the master node to the cloud provider allowing us to focus more on the development itself.

In this tutorial, we’ll see how to set up and deploy the sample Spring Boot application to Google Kubernetes Engine (GKE).

2. Prerequisites

To follow the tutorial you need the following prerequisites:

• kubectl (Kubernetes CLI to manage a cluster)
• gcloud (CLI tool to create and manage Google Cloud resources)
• Google Cloud Account (free $ 300 trial)

3. Create TestController Class With Test Endpoint

Let’s start with implementing the example TestController with getHelloMessage function:

@RestController
@RequestMapping("/api/hello")
class TestController {

    @GetMapping
    fun getHelloMessage() : ResponseEntity<String> = ResponseEntity.ok("Hello world!")
}

This is a very straightforward function responding to GET requests to /api/hello and returning “Hello world!” String as the response.

4. Create Dockerfile

As the next step, let’s prepare the Dockerfile we will use to build the Docker image later:

FROM openjdk
VOLUME /tmp
RUN mkdir /work
COPY . /work
WORKDIR /work
RUN /work/gradlew build
RUN mv /work/build/libs/*.jar /work/app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/work/app.jar"]

5. Build Docker Image

Secondly, let’s build a Docker image using already prepared Dockerfile:

docker build -t spring-boot-example .

When the command finishes its execution we will be informed that the image has been built and tagged successfully. We can also type docker images in the terminal to list all top-level images:

docker images

## command output
REPOSITORY                                          TAG                 IMAGE ID            CREATED              SIZE
spring-boot-example                                 latest              52eaa2a8ef8c        About a minute ago   1.12GB
openjdk                                             latest              0cd6de5fdbee        About a minute ago   511MB

As can be seen, the spring-boot-example image has been created and the OpenJDK image has been pulled as well.

6. Push Docker Image to Container Registry

As the next step, we will push the created image to the Google Container Registry. Before we will be able to do it, let’s make sure that we’ve got the container registry already configured and choose a correct hostname, which specifies the location where we will store the image.

Let’s start with tagging the local image with the registry name with the docker tag command:

docker tag spring-boot-example gcr.io/[PROJECT-ID]/spring-boot-example:0.0.1

Then, let’s push our image to the container registry:

docker push gcr.io/[PROJECT-ID]/spring-boot-example:0.0.1

Finally, when the command finishes its execution we can validate, whether the image has been uploaded successfully by listing Google Container Registry images:

gcloud container images list

## command output
NAME
gcr.io/[PROJECT-ID]/spring-boot-example

Please notice, that [PROJECT-ID] will be different depending on our project’s id.

7. Create a Cluster

Finally, we can create a new Kubernetes cluster within Google Kubernetes Engine. In this tutorial, we will use the cloud console (we could also do that using gcloud CLI). Let’s navigate to the panel and start by clicking the “Create cluster” button. Secondly, let’s configure cluster basics, like name and location type:

Then, let’s navigate to the node pools’ default-pool tab and set the number of nodes to 1 (this number will be bigger in the real scenarios, but for the educational purposes we do not need more):

As the last step, let’s click the Nodes tab, choose our machine type and boot disk size and click the “Create” button at the bottom of the site:

Please notice, that it may take some time before the changes will take place.

8. Create Kubernetes Deployment and Service

In order to run our application in the K8s environment, we will prepare two configuration files- one for the Deployment and one for the Service. In a nutshell, a Deployment is an object representing an application running on our cluster and a Service allows us to expose an application as a network service.

8.1. Create Deployment

Firstly, let’s create the deployment.yaml file containing the following configuration:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-boot-example
  labels:
    app: spring-boot-example
spec:
  replicas: 1
  selector:
    matchLabels:
      app: spring-boot-example
  template:
    metadata:
      labels:
        app: spring-boot-example
    spec:
      containers:
        - image: gcr.io/[PROJECT-ID]/spring-boot-example:0.0.1
          name: spring-boot-example-container
          imagePullPolicy: Always
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 5
            failureThreshold: 5
          livenessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 5
            failureThreshold: 5

Please remember to replace [PROJECT-ID] with the correct value.

8.2. Create Service

Similarly, let’s create the service.yaml file containing service’s configuration:

apiVersion: v1
kind: Service
metadata:
  name: spring-boot-example-svc
spec:
  ports:
    - port: 80
      targetPort: 8080
      protocol: TCP
      name: http
  selector:
    app: spring-boot-example
  type: LoadBalancer

And that’s all the configuration that we need to prepare in order to set up our Pods and Service.

10. Apply Deployment and Service

10.1. Configure Kubectl Context

As one of the last steps we need to fetch the credentials of the running cluster and configure our kubectl context:

gcloud container clusters get-credentials [CLUSTER-NAME] --zone [CLUSTER-ZONE] --project [PROJECT-ID]

## command output
Fetching cluster endpoint and auth data.
kubeconfig entry generated for example-cluster.

Finally, let’s apply our configurations using the apply command:

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

11. Verification

11.1. Verify K8s Pods and Service

In order to check, whether the Pods have been created successfully let’s run kubectl get pods command:

kubectl get pods

## command output
NAME                                   READY   STATUS    RESTARTS   AGE
spring-boot-example-697976c749-klc64   1/1     Running   0          50s

As can be seen, all pods are ready and the status is Running, so we can check whether the service has been created and the external IP address has been assigned:

kubectl get svc

## command output
NAME                      TYPE           CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
kubernetes                ClusterIP      10.0.0.1     <none>        443/TCP        10m
spring-boot-example-svc   LoadBalancer   10.0.4.57    34.69.49.59   80:31509/TCP   2m56s

11.2. Verify Test Endpoint

Finally, let’s check our test endpoint:

curl 34.69.49.59/api/hello

And we see that we Hello world! text is returned as the response, meaning that our application has been deployed successfully and exposed to the world.

12. Conclusion

In this article, we’ve learned how to deploy the Spring Boot application to Google Kubernetes Engine (GKE). We’ve covered how to containerize our application, build the image, push it to Google Container Registry, and finally deploy it to GKE.

For the source code, please visit our project on GitHub.

If you are reading this paragraph, I want to know that I am more than happy that you decided to spend your time learning with Codersee and I hope that this article helped you to learn something new. If you have any ideas or comments that you would like to share with us, please let us know in the comments below, by our Facebook page or group, or by using our contact form.

The post Deploy Spring Boot application to GKE appeared first on Codersee blog- Kotlin on the backend.