DEV Community: Ashish Choudhary

Monitoring Spring Boot Applications: Part 1

Ashish Choudhary — Fri, 07 Jan 2022 19:46:44 +0000

In part 1 of this series, we will learn about JDK Flight Recorder and how we can use it to monitor a Spring Boot application.

Introduction

Application monitoring is one thing that we as developers cannot overlook. It doesn’t matter if you run a monolith or microservices application because application monitoring is a must for production workloads to know what’s happening with your application. If you are using Spring Boot, there are different ways to
monitor an application. The most popular way to monitor a Spring Boot application is to enable the spring-boot-actuator module to achieve the desired result.

More often than not, we rely on third-party tools like Appdynamics, Dynatrace, Prometheus, and Grafana to monitor our workloads. But what if I told you that you could use a tool that comes with JDK to monitor your Spring Boot applications. Could you not believe me yet? Let me introduce you to the JDK flight recorder in this article that we will use to monitor a Spring Boot application.

What is a JDK Flight Recorder?

JDK Flight Recorder is a diagnostic tool that collects events of running Java applications, JVM and OS.

JFR was a commercial feature earlier, but it has been open-sourced and made GA from OpenJDK 11 onwards. See this JEP. If you are stuck on JDK 8 like everyone else, then no worries as it seems, the work is completed to backport it to OpenJDK 8. There is no need to download it separately as JFR comes bundled with your JDK.

JDK Flight Recorder Features

You can analyze the recordings offline.
View detailed information on memory usage, garbage collection, hot methods and classes, threads, Java locks, and more.
Minimal impact on performance(<1%).
It can store events on disk and memory as well.
Create customized events as per your need with API.
Support for Event Streaming from OpenJDK 14 onwards.

Enabling JDK Flight Recorder

Using Command-line
Using jcmd tool
Using JMC

Let’s understand these options in detail.

Using Command-line

If you are using OpenJDK 11 or higher version, you can enable flight recorder by passing the flag -XX:StartFlightRecording while starting your Spring Boot or Java applications. Since you can pass the flag at an application startup, it is good to rely on JFR for your application monitoring. Following is the example:

java -XX:StartFlightRecording:filename=myrecording.jfr,duration=60s -jar myapp.jar

In this example, after enabling JFR, the data is dumped to myrecording.jfr file and analyzed using a client-side tool JDK Mission Control. JMC has to be downloaded separately as it’s not part of your JDK. It is available for download from here.

Using jcmd tool

Suppose you don’t always want JFR to monitor your application as discussed in the first option but only want to diagnose when any issue occurs. In that case, jcmd is a handy option as it will send diagnostic commands to running Java applications. You have to pass the PID of the running java process or the main class and the actual command.

jcmd 24597 JFR.start duration=60s filename=myapprecording.jfr

In the above example, we have started JFR recordings for 60-seconds on the running Java process with the PID 24597 and saved it to myapprecording.jfr file in the current directory. To view all the available commands for a running Java application, specify jcmd help. Following are some of the commands that we can use with jcmd.

jcmd 24597 help

24597:

The following commands are available:

JFR.check

JFR.configure

JFR.dump

JFR.start

JFR.stop

Here is a summary of those commands.

Using JMC

JDK Mission Control aka JMC is a GUI tool for examining the recording created by JFR. Not just that with JMC you can start recording events of a running java process. As shown in the following screenshot from the left-hand side navigation bar in JMC first you have to choose a running java process. Then right-click and choose Start Flight Recording.

Start Flight Recording

In the next window, you can go with default options or tweak them as per your needs. Then click on Finish to start the recording of events for the Spring Boot application.

Once the recording is finished automated analysis results are shown.

Automated Analysis Results

As shown in the following screenshots you can also view Java application Threads, Heap, and CPU-related details. Moreover, you can also view JVM Internals and Environment related details.

Options to view results by different categories

Java Application Thread, CPU and Heap Usage

That’s it we are done.

Conclusion

In this article, we have only covered how we can enable and use the JDK flight recorder to monitor a Spring Boot application. JDK flight recorder is a reasonable tool for monitoring application performance.

Having said that in part 2 of this series, we will try to monitor simple spring boot application startup events with JFR. We will also understand how we can use JFR event streaming to continuously monitor a Spring Boot application.

Introducing the GKE Autopilot Cluster

Ashish Choudhary — Fri, 17 Dec 2021 15:41:49 +0000

Learn about Google Kubernetes Engine Autopilot features. Also, let's find out if it is worth managing your Kubernetes worker nodes yourself.

The following is an excerpt from my book Effortless Cloud-Native App Development Using Skaffold from @packtpartner aka Packt Publishing.

It is available for order from Amazon.com and directly from Packt. This excerpt comes from chapter 8: Deploying a Spring Boot Application to the Google Kubernetes Engine Using Skaffold:

Getting started with GKE Autopilot cluster

On February 24th, 2021, Google announced the general availability of their fully managed Kubernetes services, GKE Autopilot. It is a completely managed and serverless Kubernetes as a service offering. No other cloud provider currently offers this level of automation when managing the Kubernetes cluster on the cloud. Most cloud providers leave some cluster management for you, be it managing the control planes (API server, etcd, scheduler, and so on), worker nodes, or creating everything from scratch as per your needs.

GKE Autopilot, as the name suggests, is an entirely hands-off experience, and in most cases, you only have to specify a cluster name and region, set the network if you want to, and that's it. You can focus on deploying your workloads and let Google fully manage your Kubernetes cluster. Google is offering 99.9% uptime for Autopilot pods in multiple zones. Even if you manage this yourself, you will not beat the number that Google is offering. On top of this, GKE Autopilot is cost-effective as you don't pay for Virtual Machines (VMs), and you are only billed per second for resources (for example, vCPU, memory, and disk space consumed by your pods).

GKE autopilot v/s GKE standard cluster?

So what's the difference between a GKE Standard cluster like the one we created in the previous section and a GKE Autopilot cluster? The answer is as follows: with the Standard cluster, you manage only the nodes, as the GKE manages the control plane, and with GKE Autopilot, you don't manage anything (not even your worker nodes).

This raises a question: is it a good or a bad thing that I cannot control my nodes? Now, this is debatable, but most organizations today are not handling traffic or loads like amazon. com, google.com, or netflix.com. It may be an oversimplification, but to be honest, even if you think you have specific needs or you need a specialized cluster, more often than not, you end up wasting a lot of time and resources in securing and managing your cluster.

If you have a team of SRE that can match the level of experience or knowledge of Google SRE, you can do whatever you like with your cluster. But most organizations today don't have such expertise and don't know what they are doing. That's why it is better to rely on fully managed Kubernetes services such as GKE Autopilot – it is battle-tested and hardened based on the best practices learned from Google SRE.

Conclusion

I hope you found this excerpt helpful. Chapter 8 focuses on deploying the Spring Boot application to the remote Google Kubernetes Engine (GKE), a managed Kubernetes service provided by the Google Cloud Platform (GCP) using Skaffold. We will introduce you to Google's recently launched serverless Kubernetes offering, GKE Autopilot. You will also get to know Google Cloud SDK and Cloud Shell, and use them to connect and manage a remote Kubernetes cluster. And if that’s not enough, there are ten chapters filled with Kubernetes and cloud-native goodness.

What are you waiting for? Grab your copy now.

What is GitOps, and what are its benefits?

Ashish Choudhary — Mon, 08 Nov 2021 09:31:34 +0000

Let's understand what GitOps is and its benefit. You will also learn how ArgoCD can help with the continuous delivery of the Kubernetes application.

The following is an excerpt from my book Effortless Cloud-Native App Development Using Skaffold from @packtpartner Publishing.

It is available for order from Amazon.com and directly from Packt. This excerpt comes from chapter 9: Creating a Production-Ready CI/CD Pipeline with Skaffold:

What is GitOps

The word GitOps was coined by a company named Weaveworks. The idea behind GitOps is to consider Git as a single source of truth for your application and declarative infrastructure. Using Git to manage your declarative infrastructure makes it easy for developers because they interact with Git daily. Once you add configuration inside Git, you get the benefits of version control, such as reviewing changes using pull requests, audit, and compliance.

With GitOps, we create automated pipelines to roll out changes to your infrastructure when someone pushes changes to a Git repository. Then we use GitOps tools to compare the actual production state of your application with what you have defined under source control. Then it also tells you when your cluster doesn't match what you have in production and automatically or manually reconciles it with the desired state. This is a true CD.

You can easily roll back your changes from Kubernetes by doing a simple git revert. In disaster scenarios or if someone accidentally nuked your entire Kubernetes cluster, we could quickly reproduce your whole cluster infrastructure from Git.

What are the benefits of GitOps

Using GitOps, the team is shipping 30-100 changes per day to production. Of course, you need to use deployment strategies such as blue-green and canary to validate your changes before making them available to all the users. The overall benefit is an increase in developer productivity.
You get a better developer experience with GitOps as developers are pushing code and not containers. Moreover, they use familiar tools such as Git and don't need to know about the internals of Kubernetes (that is, kubectl commands).
By putting declarative infrastructure as code in the Git repository, you automatically get benefits such as audit trail for your cluster, such as who did what and when. It further ensures the compliance and stability of your Kubernetes cluster.
You can also recover your cluster faster, in case of a disaster, from hours to minutes because your entire system is described in Git.
Your application code is already on Git, and with GitOps, your operation tasks are part of the same end-to-end workflows. You have a consistent Git workflow across your entire organization.

It's only fair that we also cover some details about Argo CD so that it's easier to understand the later part where we implement a GitOps workflow using Skaffold and Argo CD.

What is Argo CD?

As per the official documentation of Argo CD, it is a declarative, GitOps continuous delivery tool for Kubernetes. In the previous section, we used the term GitOps tool that can compare and sync the application state if it deviates from what we have defined in the Git repository, so it is safe to say that Argo CD is the tool that handles this automation.

Kubernetes introduced us to the concept of control loops through which Kubernetes checks whether the number of replicas running matches with the desired number of replicas. Argo CD leverages the same Kubernetes (K8s) capabilities, and its core component is argocd-applicationcontroller, which is basically a Kubernetes controller. It monitors the state of your
application and adjusts the cluster accordingly.

Conclusion

I hope you found this excerpt helpful. Chapter 9 covers the practical knowledge of how you can use GitHub Actions to automate your development workflows. We have also explained how you could build, test, and deploy your Java applications from your GitHub repository. Then we described how you could create a CI/CD pipeline for your Kubernetes applications using Skaffold and GitHub Actions. And if that’s not enough, there are ten chapters filled with Kubernetes and cloud-native goodness. What are you waiting for? Grab your copy now.

Spring Boot and Java 16 Records

Ashish Choudhary — Sat, 20 Mar 2021 06:07:28 +0000

In this article, we will discuss Java 16's newest feature, Records. Then we will apply this knowledge and use it in conjunction with a Spring Boot application.

Introduction

On March 16th, 2021, Java 16 was GA. With this new release, tons of new exciting features are added. Check out the release notes to know more about these changes in detail. This article's focus will be on Java Records, which got delivered with JEP 395. Records were first introduced in JDK 14 as a preview feature proposed by JEP 359, and with JDK 15, they remained in preview with JEP 384. However, with JDK 16, Records are no longer in preview.

I have picked records because they are definitely the most favored feature added in Java 16, according to this Twitter poll by Java Champion Mala Gupta.

// Detect dark theme var iframe = document.getElementById('tweet-1367274033184575497-540'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1367274033184575497&theme=dark" }

I also conducted a similar survey, but it was focused on features from Java 8 onwards. Lambdas, Stream and Optional got the most votes in this poll. The results were not unexpected as Java 8 is still widely used. Very unfortunate, though, as tons of new features and improvements are added to newer Java versions. But in terms of features, Java 8 was definitely a game-changer from a developer perspective.

// Detect dark theme var iframe = document.getElementById('tweet-1353207204761899010-529'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1353207204761899010&theme=dark" }

For some more Java and tech-related stuff, follow me on Twitter

So let's discuss what's the fuss is about Java Records.

What are Records?

As per the JEP 395:

Records are a new kind of class in the Java language. They act as transparent carriers for immutable data with less ceremony than normal classes. Records can be thought of as nominal tuples.

Another quote from the JEP clearly explains developers' frustration while writing typical data carrier classes.

Properly writing such a data-carrier class involves a lot of low-value, repetitive, error-prone code: constructors, accessors, equals, hashCode, toString, etc. For example, a class to carry x and y coordinates inevitably ends up like this:

class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    int x() { return x; }
    int y() { return y; }

    public boolean equals(Object o) {
        if (!(o instanceof Point)) return false;
        Point other = (Point) o;
        return other.x == x && other.y == y;
    }

    public int hashCode() {
        return Objects.hash(x, y);
    }

    public String toString() {
        return String.format("Point[x=%d, y=%d]", x, y);
    }
}

Another option that we developers use most often is to leave the handling of the boilerplate to IDE. For example, with Intellij, you can generate constructors, getters, setters, equals, hashCode, and toString, etc., by simply pressing Command + N shortcut key. But the boilerplate code is still there.

With Java 16 Records, it's just one line of code. Cool, isn't it.

record Point(int x, int y) { }

Here a record class declaration consists of a name, optional type parameters, a header, and a body.

Demystifying Records

Internals of the Java record class can be checked using a decompiler that comes with IntelliJ IDE or can use the javap command-line utility. To understand the internals, we created the following record class.

public record State(String name, String capital) {}

Following is the decompiled Java record class. I have used the javap command-line utility to check class file internals.

 $ javap State.class

Following is the output.

Compiled from "State.java"
public final class com.example.indianstates.State extends java.lang.Record {
  public com.example.indianstates.State(java.lang.String, java.lang.String);
  public final java.lang.String toString();
  public final int hashCode();
  public final boolean equals(java.lang.Object);
  public java.lang.String name();
  public java.lang.String capital();
}

You can conclude the following from the above output.

State record class is extending the java.lang.Record abstract class.
State record class is declared final cannot be extended further using extends keyword.
hashCode(), equals(), toString() and a canonical constructor are implicitly generated for us.
There are no setters or getters, only accessors.
With no setters and final in the class declaration clarifies that you cannot change the state, and hence records are immutable.

You can further validate these points by writing tests as well.

    @Test
    public void testRecordAccessors() {
        String name = "Maharashtra" ;
        String capital = "Mumbai" ;
        State state = new State("Maharashtra", "Mumbai");
        Assert.assertEquals(name, state.name());
        Assert.assertEquals(capital, state.capital());
    }

    @Test
    public void testRecordToString() {
        State state = new State("Maharashtra", "Mumbai");
        System.out.println(state);
        //Output:-State[name=Maharashtra, capital=Mumbai]
    }

    @Test
    public void testRecordEquals() {
        State state1 = new State("Maharashtra", "Mumbai");
        State state2 = new State("Maharashtra", "Mumbai");
        Assert.assertTrue(state1.equals(state2));
    }

    @Test
    public void testRecordHashCode() {
        State state1 = new State("Maharashtra", "Mumbai");
        State state2 = new State("Maharashtra", "Mumbai");
        Assert.assertEquals(state1.hashCode(), state2.hashCode());
    }

There are some restrictions in the declaration of record classes as compared to normal classes. Checkout JEP 395 for such restrictions.

Lombok and Records, Friends or Foe?.

You are probably already using Lombok annotations such as @Value, which is closest if not the same to the Java records. Then you can get rid of one dependency and those Christmas trees of annotations. I might have oversimplified things, and it may make sense to replace Lombok for some cases. But you might be using Lombok for other features and not just one annotation that it provides. And believe me, while Java Records are a welcome feature for Java lovers, but it's not going to replace Lombok, at least for now. You do not believe me? Check out this answer from Brain Goetz on StackOverflow.

And be careful with what dependencies you add to your project as the problem that is part of that dependency becomes your problem too.

Spring Boot and Java Records

From version 2.5.0-M1 onwards, Spring Boot provides preliminary support for Java 16. I have a working Spring Boot application that I will use to demo Java records with it. The source code is available here.
This is a simple Spring Boot application which, when accessed via /states or /state?name=statename REST endpoint show all or specific Indian states and their capitals. This application uses an in-memory H2 database that inserts rows at the start of the application.

As always, you can use start.spring.io to generate stubs for your Spring Boot application, and as explained earlier, make sure that you select the 2.5.x milestone version.

Here is how the REST controller class looks like.

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class Controller {
    private final StateService stateService;

    public Controller(StateService stateService) {
        this.stateService = stateService;
    }

    @GetMapping("/states")
    private List<State> getAllStates() {
        return stateService.findAll();
    }

    @GetMapping(value = "/state")
    private String getSpecificState(@RequestParam(required = false, name = "name", defaultValue = "Maharashtra") String name) {
        return stateService.findByName(name);
    }
}

We can focus on the getAllStates() method, which returns a list of State record class objects.

We have already seen the State record class. There is no change in that.

public record State(String name, String capital) {}

Following is the StateRepository interface implemented by the StateService class.

import java.util.List;

public interface StateRepository {
    List<State> findAll();

    String findByName(String name);
}

@Service
public class StateService implements StateRepository{
    private final JdbcTemplate jdbcTemplate;

    public StateService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    private final RowMapper<State>  rowMapper = (rs, rowNum) -> new State(rs.getString("name"),rs.getString("capital"));

    @Override
    public List<State> findAll() {
        String findAllStates = """
                select * from States
                """;
        return jdbcTemplate.query(findAllStates, rowMapper);
    }

    @Override
    public String findByName(String name) {
        String findByName = """
                select capital from States where name = ?;
                """;
        return jdbcTemplate.queryForObject(findByName, String.class, name);
    }
}

StateService is autowired using the constructor of the Controller class. It has a method named findAll() that uses Spring JdbcTemplate to query and returns a State record class list from the in-memory H2 database. As you can see, we have used the RowMapper functional interface, which JdbcTemplate uses for mapping rows of a ResultSet on a per-row basis, and it returns the Row object for the current row. We have also used the new keyword to initialize the record class, which means we can initialize the record class like normal classes in Java. I have also used the Java 15 Text Blocks feature, which helps in the readability of SQL queries and JSON string values.

However, there were some issues when I started using records with this application. Earlier I was using BeanPropertyRowMapper, which resulted in the following exception when I disabled Lombok and used Records instead for the State class.

2021-03-19 02:01:55.434 ERROR 66059 --- [nio-8080-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is org.springframework.beans.BeanInstantiationException: Failed to instantiate [com.example.indianstates.State]: No default constructor found; nested exception is java.lang.NoSuchMethodException: com.example.indianstates.State.<init>()] with root cause

From the exception and BeanPropertyRowMapper documentation it is pretty clear that we must declare a default or no-arg constructor in the State records class, which leads to some interesting discoveries about the records classes in Java.

To solve this error, I naively added a no-arg constructor to the State record class.

public record State(String name, String capital) {
    public State() {
    }
}

But, that resulted in the following compilation error.

Non-canonical record constructor must delegate to another constructor

To solve this compilation, I added the following constructor, but this will make the values null in the response.

public record State(String name, String capital) {
    public State() {
        this(null,null);
    }
}

Then I took the help of the IntelliJ feature to generate the constructor for this record class. It provided me with the following options.

I tried these options but got the same result. I already knew that these options wouldn't work, but I tried my luck, which makes me wonder how to use records with BeanPropertyRowMapper. I don't have an answer for this right now, but I will dig this further. If you see any issue with the code or have a better answer, then let me know.

Update:- I posted these exceptions to Spring Boot Gitter chat and got this answer.

BeanPropertyRowMapper can't be used with records since it consists of creating an instance of a Java Bean with its no-arg constructor and then calling its setters to populate the bean. But records don't have a no-arg constructor and are immutable and thus don't have setters. So, either use a traditional Java Bean or use records, but then don't use BeanPropertyRowMapper.

Fair enough. So clearly BeanPropertyRowMapper cannot be used with records.

It's a wrap for now. Happy coding.

Conclusion

In this article, you have learned that Records are immutable data carrier classes that reduce lots of boilerplate code that we are used to writing. Then we looked at the internals of a Record class and discovered that hashCode(), equals(), toString(), and constructors are implicitly generated for us by the compiler. Then we learned that you should not really compare or replace Records with external libraries like Lombok because both are different tools for different things.

In the last section, we discovered that Records are good for use in cases such as getting data from a database (or some external service) with an example of the Spring Boot application. We also discovered some issues while using BeanPropertyRowMapper, and concluded that we could not use it with records.

Support me

If you like what you just read, then you can buy me a coffee by clicking the link in the image below:

Demystifying Google Container Tool Jib: Java Image Builder

Ashish Choudhary — Thu, 21 Jan 2021 04:21:36 +0000

This article covers some internals of image layering created by container image builder Jib and explore what distroless images are and their benefits.

Are you are wondering what Jib is, actually?. You probably should read my previous article before going ahead.

Jib is an excellent tool for Java developers who are interested in containerizing Java applications but not so interested in creating and maintaining Dockerfile or installing Docker.
A Java developer can add a plugin to Maven or Gradle, and that's it. You don't have to learn new technology just to containerize your Java application.

Now let's talk about some internals.

Jib Image Layering

Jib intelligently divides your images into the following layers for more granular incremental builds.

Dependencies
Resources
Classes
Snapshot dependencies
All other dependencies Each extra directory (jib.extraDirectories in Gradle, in Maven) builds to its own layer

When you do any code changes, only your changes are rebuilt, not your entire application. Which means Jib only pushes the layer which is changed and the rest of the layers remain the same.
For example, in the following demo, only a class file was changed and Jib pushed only the compiled class layer. Later on, we could see that during the docker pull only the changed layer was extracted.

Furthermore to dig deeper, now we will use the simple spring boot application that was used in the previous article. The source code is available here. We will run maven in debug mode to understand these layers. However, In the following logs, you will see only dependencies, resources, and classes as separate layers since we don't have other dependencies.

Deep Dive Image Layer

You can inspect images created by Jib using the Dive tool. As you can see on RHS, we have exploded directory structure for classes, resources and dependencies in the following path and their size is very minimal.

/apps/classes,/apps/libs,/apps/resources

Rest of the contents are of your base image.

Dive also tells you if you are wasting any space and if you are then you can discover ways to shrink the size of your Docker/OCI image. However, in our case, no space is wasted :).!
You can view the content of an image with a docker history command as well. Let's see what it looks like.

What are Distroless Images?

Google defines distroless images as the following:

Distroless images are lightweight base images as they contain only dependencies required to run your application. They do not contain package managers, shells or any other programs you would expect to find in a standard Linux distribution.

Furthermore, the layers created by Jib are created on top of a distroless base image. Jib by default uses distroless Java 8 image but you have the option to choose an image of your choice.

Why Distroless?

Fewer vulnerabilities to patch
Better security
Built with minimum dependencies

Debugging Distroless Images

Since there are no package managers installed and you cannot do ssh to your container running with distroless base image makes them hard for debugging. In an ideal world, you would add better logging then you know enable shell access for your containers. But there are ways with which you can add shell support and debug your application.

Conclusion

In this article, we have covered some internals about Jib .i.e. image layering which makes it fast. We have also covered distroless images with their benefits and pitfalls like debugging.

Support me

If you like what you just read then you can buy me a coffee

Further reading

You can also read some of my previous articles

Local Variable Type Inference: Declare var, not war

Ashish Choudhary — Wed, 30 Dec 2020 20:49:22 +0000

In this article, I will try to explain Java 10 new feature local variable type inference using reserved type name var.

Java is changing rapidly and with the new release cycle of 6 months, we are getting new features to try with every release. In Java 10 a new feature Local-Variable Type Inference was added. It was basically aimed at reducing boilerplate code and improving the readability when declaring local variables with initializers.

Programs must be written for people to read, and only incidentally for machines to execute~Harold Abelson

Let's understand this with an example. Following code is written without using Local-Variable Type Inference.

After refactoring as per Java 10 local variable type inference.

In the above-refactored code, the compiler can infer the declared type itself by looking at the RHS declaration.
These are just some of the examples to make you understand the feature and how we can use local variable type inference.

Now let's understand where local variable type inference can be used and where it cannot be.

Where it can be used

Local variable initializers
Indexes in the enhanced forloop
Locals declared in a traditional forloop
Resource variables of the try-with-resources statement
Formal parameters of implicitly typed lambda expressions. (Support added in Java 11)

The following code snippet shows some valid examples.

Where it cannot be used

Fields
Method parameters
Method return types
Local variable declarations without any initialization
Cannot use null for initialization

I have tried to explain in the below code snippet what compiler error will come if it is used in a not supported way.

What's the benefit?

If you ask me personally I think developers should use it judiciously. It is understood that there is excitement whenever a feature comes in and you definitely want to give it try. But you have to understand that we as a developer read code more often then we write it.

Since this is related to readability then some folks will like it and some will hate it. So if during a code review someone says that he is not able to get the declared type of var then it means that it is not very clear to others so maybe switching back to the old-fashioned way where we declare types explicitly is not that bad after all. Again in some situations declared type is quite obvious then you can skip the explicitly declared type and make use of the var.

Conclusion

In this article, we have covered what is Local-Variable Type Inference new Java 10 feature with some examples where it can be used and where it's not supported. You can further read these FAQs prepared by the OpenJDK team about Local-Variable Type Inference.

Support me

If you like what you just read then you can buy me a coffee

Deploying Spring Boot Application on Kubernetes

Ashish Choudhary — Wed, 23 Dec 2020 17:56:18 +0000

In this article, I will explain how you can create a pod, deploy a spring boot application, manage the single node cluster with Lens IDE on Docker Desktop.

What you will learn.

How to Enable Kubernetes With Docker Desktop for Mac
How to Create a Pod
How to Deploy a Working Spring Boot Application on Kubernetes
How to Monitor and Manage Kubernetes Cluster with Lens IDE

Moving on, you may not know this, but you can have a functional single-node Kubernetes cluster running locally with your Docker Desktop by following the below steps. But wait, What is Docker Desktop?

What is Docker Desktop?

As per the official documentation.

Docker Desktop is an application for macOS and Windows machines for the building and sharing of containerized applications and microservices.

You can follow the official Docker Desktop installation guide if you have not installed it already.

How to Enable Kubernetes With Docker Desktop for Mac

Go to Preferences in the Docker menu bar. Then click the Kubernetes tab. Click the checkbox to enable Kubernetes and switch the default orchestrator to Kubernetes. It will take some time to enable Kubernetes.

Once it is enabled you will see something like below on your Docker menu bar.

Next, You should also set the Kubernetes context to docker-desktop if you have multiple clusters or environments running locally.

As per official documentation the mac Kubernetes integration provides the Kubernetes CLI command at /usr/local/bin/kubectl. This location may not be in your shell’s PATH variable, so you may need to type the full path of the command or add it to the PATH.

kubectl is a Kubernetes CLI tool for running commands against your cluster. Know more about kubectl here. Now we can verify the setup using the below kubectl command. The output should be something similar to the below.

kubectl get nodes
NAME             STATUS   ROLES    AGE   VERSION
docker-desktop   Ready    master   19d   v1.19.3

How to Create a Pod

A Pod in Kubernetes is the smallest possible execution unit. It can have one more container in it. However, we will test the setup by creating a simple pod with a single container image on the local Kubernetes cluster by following the below steps. This container runs an Nginx image.

Create a pod using the below YAML file.

apiVersion: v1
kind: Pod
metadata:
name: nginx
labels:
app: nginx
spec:
containers:
- name: mycontainer
image: docker.io/nginx
ports:
- containerPort: 80

Use kubectl create and the name of the YAML file to create a pod.

kubectl create -f pod.yaml
pod/nginx created

2. Check the status of the pod we just created.

kubectl get pods
NAME    READY   STATUS    RESTARTS   AGE
nginx   1/1     Running   0          2m38s

3. To debug the pod further and it’s working we can get a shell to a running container using kubectl exec command. Once inside the container, we will just use curl to verify Nginx setup. Let’s do that now.

kubectl exec -it nginx -- /bin/sh
# curl 10.1.0.65
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
body {
width: 35em;
margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif;
}
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>

How to Deploy a Working Spring Boot Application on Kubernetes

Let’s deploy a working Spring Boot application on our local Kubernetes cluster. We will be using the Indian-states application for the demo. You can check out this GitHub repository to know more about this application.

In my previous article, I have already explained the service and deployment resources for this Kubernetes application.

Now we will just clone this repository and create Kubernetes manifests using the below command.

git clone https://github.com/yrashish/indian-states
cd indian-states/k8s
kubectl create -f myservice.yaml
service/states created
kubectl create -f mydeployment.yaml
deployment.apps/states created
kubectl get all
NAME                          READY   STATUS    RESTARTS   AGE
pod/states-6664b9dbf6-l2tgj   1/1     Running   0          8s
NAME                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
service/kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP          55s
service/states       NodePort    10.96.78.225   <none>        8080:31238/TCP   15s
NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/states   1/1     1            1           8s
NAME                                DESIRED   CURRENT   READY   AGE
replicaset.apps/states-6664b9dbf6   1         1         1       8s

Now just do curl and access the /states REST endpoint and see what happens.

curl localhost:31238/states
[{“name”:”Andra Pradesh”,”capital”:”Hyderabad”},{“name”:”Arunachal Pradesh”,”capital”:”Itangar”},{“name”:”Assam”,”capital”:”Dispur”},{“name”:”Bihar”,”capital”:”Patna”},{“name”:”Chhattisgarh”,”capital”:”Raipur”},{“name”:”Goa”,”capital”:”Panaji”},{“name”:”Gujarat”,”capital”:”Gandhinagar”},{“name”:”Haryana”,”capital”:”Chandigarh”},{“name”:”Himachal Pradesh”,”capital”:”Shimla”},{“name”:”Jharkhand”,”capital”:”Ranchi”},{“name”:”Karnataka”,”capital”:”Bangalore”},{“name”:”Kerala”,”capital”:”Thiruvananthapuram”},{“name”:”Madhya Pradesh”,”capital”:”Bhopal”},{“name”:”Maharashtra”,”capital”:”Mumbai”},{“name”:”Manipur”,”capital”:”Imphal”},{“name”:”Meghalaya”,”capital”:”Shillong”},{“name”:”Mizoram”,”capital”:”Aizawi”},{“name”:”Nagaland”,”capital”:”Kohima”},{“name”:”Orissa”,”capital”:”Bhubaneshwar”},{“name”:”Rajasthan”,”capital”:”Jaipur”},{“name”:”Sikkim”,”capital”:”Gangtok”},{“name”:”Tamil Nadu”,”capital”:”Chennai”},{“name”:”Telangana”,”capital”:”Hyderabad”},{“name”:”Tripura”,”capital”:”Agartala”},{“name”:”Uttaranchal”,”capital”:”Dehradun”},{“name”:”Uttar Pradesh”,”capital”:”Lucknow”},{“name”:”West Bengal”,”capital”:”Kolkata”},{“name”:”Punjab”,”capital”:”Chandigarh”}]

How to Monitor and Manage Kubernetes Cluster with Lens IDE

Lens IDE for Kubernetes is a desktop application for macOS, Windows, and Linux to manage your cluster. It's completely free and open source. You can download it from here. Developers, DevOps engineers, SRE, and also people who are learning Kubernetes on their laptops can use this to view and manage their clusters. Following are some of the highlighted features that it provides.

Manage multiple clusters with a single IDE.
360-degree view of your cluster.
Prometheus integration
Context-aware built-in terminal
Built-in support for managing Helm charts

After installing it you can first add a cluster. Lens connects to your Kubernetes cluster using the kubeconfig file which is typically located in your $HOME/.kube directory. You have the option to paste it as a text file also. Now select the kubeconfig file, context, and click on Add cluster.

After adding the cluster you can see it on the left side navigation bar. For demo purposes, I have redeployed the Spring Boot application. Under events, you can see that our application image is getting pulled.

We can also view the logs of the deployment we just completed. As you can see that application is deployed and running.

You can scale, restart, edit and remove Kubernetes manifests from Lens IDE itself.

Under networks, you can also view Kubernetes services.

Lens has a feature where it allows you to install Prometheus stack in your cluster so that you can gather metrics about the cluster and its nodes. For installation, right-click on the cluster icon in the Lens UI's top-left corner and select Settings.

On the Settings page, under features, you can see a Metrics section and a button to install Prometheus. Click Install to deploy the Prometheus stack to your cluster.

Lens will start displaying metrics after a minute or so.

We have only covered a handful of features that Lends IDE for Kubernetes provides. It's a wrap for now.

Conclusion

In this article, we have learned how to enable Kubernetes on Docker Desktop for Mac, created a basic pod, deployed a Spring Boot application, and managed our single-node Kubernetes cluster with the help of Lens IDE. What are you waiting for? Go Containerize and share your applications?

Support me

If you like what you just read, then you can buy me a coffee by clicking the link in the image below:

10 Books Every Java Developer Must Read

Ashish Choudhary — Sat, 12 Dec 2020 14:10:33 +0000

A curated list of books that every experienced Java developer must-read.

Covers topics such as concurrency, microservices, new feature addition in java, best practices, frameworks, etc.

Effective Java

Modern Java

Concurrency in practice

Java Module System

Cloud Native Java

Microservices Pattern

Clean code

Head first design pattern

SpringBoot in action

Java performance tunning

Finally Native Reactive JDBC Driver for Oracle Database

Ashish Choudhary — Thu, 10 Dec 2020 12:36:07 +0000

We finally have Reactive extensions for the Oracle JDBC driver that uses java.util.concurrent.Flow and Reactive streams.

The Reactive Extensions are a set of methods that extend the JDBC standard to offer asynchronous database access.

The Reactive Extensions use non-blocking mechanisms for creating Connection objects, executing SQL statements, fetching rows, committing transactions, rolling back transactions, closing Connection objects, and reading and writing BFILEs, BLOBs, and CLOBs.
You can read more details here

Running a Simple Spring Boot Application on OpenShift

Ashish Choudhary — Wed, 09 Dec 2020 15:07:05 +0000

In this article, I will try to demonstrate how to deploy a simple Spring Boot application on OpenShift (Minishift).

But wait what the hell is OpenShift after all?.

OpenShift is RedHat’s cloud development Platform as a Service (PaaS). It is built on top of Docker containers and the Kubernetes container cluster orchestrator.

What is Paas?.

As per Wikipedia

Platform as a service* (PaaS) or application platform as a service (aPaaS) or platform-based service is a category of cloud computing services that provides a platform allowing customers to develop, run, and manage applications without the complexity of building and maintaining the infrastructure typically associated with developing and launching an app.

What is Minishift then?.

Minishift is a tool that helps you run OpenShift locally by running a single-node OpenShift cluster inside a VM. You can try out OpenShift or develop with it, day-to-day, on your localhost.

Let’s get started then. I will be installing it on my mac but there are plenty of blogs/resources available explaining how to install it on other popular OS like Windows, Linux.

Installation

You can go through the official installation instructions or follow the steps mentioned below to run Minishift locally on macOS.

Set up your virtualization environment
Download Minishift software for your operating system from the Minishift Releases page
Install Minishift
Start Minishift
Configure Minishift so you can use it efficiently.

As explained in point 4 you can start Minishift with the below command

minishift start

Once you run the above command Minishift performs some system checks like this.

Starting profile ‘minishift’
Check if deprecated options are used … OK
Checking if https://github.com is reachable … OK
Checking if requested OpenShift version ‘v3.11.0’ is valid … OK
Checking if requested OpenShift version ‘v3.11.0’ is supported … OK
Checking if requested hypervisor ‘xhyve’ is supported on this platform ..OK
Checking if xhyve driver is installed …
If everything is OK then you would see message like this at then end of your terminal.
OpenShift server started.
The server is accessible via web console at:
https://192.168.64.3:8443/console

Accessing Web Console

Now you are good to go and browse the Minishift web console which is accessible by default using this URL https://192.168.64.3:8443/console. Since there is no authentication/authorization enabled by default you can create your own username and password when logging in for the first time.

Minishift Login page

Creating a Project

You have the option to create projects etc. via the command line and via the web console. We will be using the command line option. First login using below command as an admin user.

oc login -u system:admin

Then by default, we can use the default project which is myproject for this demo. Alternatively, you can create a new project also.

Creating Application

Now you need to select a base image for the application that you are going to create. Since this is a spring boot project we will be using an open jdk8 base image for our application. Use the below command line command to create an application with an openjdk8 base image.

oc new-app registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift~https://github.com/userac/springboot-kubernetes.git — name=springboot-demo-openshift

Output of above command

> → Found Docker image 6c975f1 (2 weeks old) from registry.access.redhat.com for “registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift”
> Java Applications
> — — — — — — — — -
> Platform for building and running plain Java applications (fat-jar and flat classpath)
> Tags: builder, java
> * An image stream tag will be created as “openjdk18-openshift:latest” that will track the source image
> * A source build using source code from [https://github.com/userac/springboot-kubernetes.git](https://github.com/userac/springboot-kubernetes.git) will be created
> * The resulting image will be pushed to image stream tag “springboot-demo-openshift:latest”
> * Every time “openjdk18-openshift:latest” changes a new build will be triggered
> * This image will be deployed in deployment config “springboot-demo-openshift”
> * Ports 8080/tcp, 8443/tcp, 8778/tcp will be load balanced by service “springboot-demo-openshift”
> * Other containers can access this service through the hostname “springboot-demo-openshift”
> → Creating resources …
> imagestream.image.openshift.io “openjdk18-openshift” created
> imagestream.image.openshift.io “springboot-demo-openshift” created
> buildconfig.build.openshift.io “springboot-demo-openshift” created
> deploymentconfig.apps.openshift.io “springboot-demo-openshift” created
> service “springboot-demo-openshift” created

Build Status

Once the application is created the build will be automatically scheduled using S2I. You can view the logs using the below command to check the status of the build.

oc logs -f bc/springboot-demo-openshift

Output of above command

> Cloning “https://github.com/userac/springboot-kubernetes.git" …
> Commit: bdf1e3a36a7c16b69567de1b5343ff9c51114536 (changing message)
> Author: ashishchoudhary
> Date: Sun Mar 22 00:22:23 2020 +0530
> Using registry.access.redhat.com/redhat-openjdk-18/openjdk18-openshift@sha256:fa5f725ba5d0ed29f680a21d49e87d88ef0bad3db83158496eda33533cca10f8 as the s2i builder image
> INFO Performing Maven build in /tmp/src
> INFO Using MAVEN_OPTS -XX:+UseParallelOldGC -XX:MinHeapFreeRatio=10 -XX:MaxHeapFreeRatio=20 -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -XX:MaxMetaspaceSize=100m -XX:+ExitOnOutOfMemoryError
> INFO Using Apache Maven 3.6.1 (Red Hat 3.6.1–6.3)
> Maven home: /opt/rh/rh-maven36/root/usr/share/maven
> Java version: 1.8.0_272, vendor: Red Hat, Inc., runtime: /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.272.b10–1.el7_9.x86_64/jre
> Default locale: en_US, platform encoding: ANSI_X3.4–1968
> OS name: “linux”, version: “3.10.0–1127.19.1.el7.x86_64”, arch: “amd64”, family: “unix”
> INFO Running ‘mvn -e -Popenshift -DskipTests -Dcom.redhat.xpaas.repo.redhatga -Dfabric8.skip=true — batch-mode -Djava.net.preferIPv4Stack=true -s /tmp/artifacts/configuration/settings.xml -Dmaven.repo.local=/tmp/artifacts/m2 package’
> [INFO] Error stacktraces are turned on.
> [INFO] Scanning for projects…
> [INFO] Downloading from central: [https://repo1.maven.org/maven2/org/springframework/boot/spring-boot-starter-parent/2.2.4.RELEASE/spring-boot-starter-parent-2.2.4.RELEASE.pom](https://repo1.maven.org/maven2/org/springframework/boot/spring-boot-starter-parent/2.2.4.RELEASE/spring-boot-starter-parent-2.2.4.RELEASE.pom)
> [INFO] Downloaded from central: [https://repo1.maven.org/maven2/org/springframework/boot/spring-boot-starter-parent/2.2.4.RELEASE/spring-boot-starter-parent-2.2.4.RELEASE.pom](https://repo1.maven.org/maven2/org/springframework/boot/spring-boot-starter-parent/2.2.4.RELEASE/spring-boot-starter-parent-2.2.4.RELEASE.pom) (8.1 kB at 1.7 kB/s)…….
> INFO] BUILD SUCCESS
> [INFO] — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
> [INFO] Total time: 02:44 min
> [INFO] Finished at: 2020–11–11T05:07:46Z
> [INFO] — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
> [WARNING] The requested profile “openshift” could not be activated because it does not exist.
> INFO Copying deployments from target to /deployments…
> ‘/tmp/src/target/springboot-kubernetes-0.0.1-SNAPSHOT.jar’ -> ‘/deployments/springboot-kubernetes-0.0.1-SNAPSHOT.jar’
> Pushing image 172.30.1.1:5000/myproject/springboot-demo-openshift:latest …
> Pushed 0/4 layers, 1% complete
> Pushed 1/4 layers, 29% complete
> Pushed 2/4 layers, 70% complete
> Pushed 3/4 layers, 95% complete
> Pushed 4/4 layers, 100% complete
> Push successful

Once the build is triggered you can see that S2I is doing its work as expected by cloning the repository first and then doing the build. Later on, after the build is a success as seen above the image will push for further execution. You’ve just built and run a new runnable container image from source code in a git repository.

Now let’s understand what an S2I is actually?

S2I

As per the Openshift documentation, Source-to-Image (S2I) is a toolkit and workflow for building reproducible container images from source code. S2I produces ready-to-run images by injecting source code into a container image and letting the container prepare that source code for execution. By creating self-assembling builder images, you can version and control your build environments exactly like you use container images to version your runtime environments.

Status

Run ‘oc status’ to view the status of your app.

oc status

Output of above command

> In the project My Project (myproject) on server [https://192.168.64.4:8443](https://192.168.64.4:8443)
> svc/springboot-demo-openshift — 172.30.105.115 ports 8080, 8443, 8778
> dc/springboot-demo-openshift deploys istag/springboot-demo-openshift:latest <-
> bc/springboot-demo-openshift source builds [https://github.com/userac/springboot-kubernetes.git](https://github.com/userac/springboot-kubernetes.git) on istag/openjdk18-openshift:latest
> deployment #1 deployed 20 minutes ago — 1 pod

As you can see that there is 1 pod running. You can view the same status on the web console also. You would see something like below. If you carefully observe we have not exposed the application to the outside world yet because we have not created a route. Let’s do that now and see if we can access the application.

Route

As explained above our application is not exposed to the outside world we can expose our services by executing one or more of the commands below:

oc expose svc/springboot-demo-openshift

Output of the above command

route.route.openshift.io/springboot-demo-openshift exposed

Similarly, if you goto web console applications>routes. You can see that route is created. Now our application is exposed to the outside world. Cool.

Route created

Let’s hit the URL and access our spring boot demo application.

We have successfully deployed our first Spring boot demo application to Openshift locally.

Support me

If you like what you just read then you can buy me a coffee

Further reading

You can also read one of my previous articles

Best Book To Understand Latest Java Features

Ashish Choudhary — Wed, 09 Dec 2020 10:05:36 +0000

There are a lot of changes done in Java after version 8 and if you are wondering what are those new features then I would recommend reading this book. It sums up new features with examples from 8 onwards also. Worth reading. Go buy your copy now.

Containerizing Spring Boot Application with Jib

Ashish Choudhary — Tue, 08 Dec 2020 19:47:29 +0000

In this post, we will learn about how to create Docker or OCI compliant images, without installing any Docker client and without using a Dockerfile, for a Spring Boot application.

We will be doing all of this with the help of Jib aka Java Image Builder.

What Is Jib?

Jib is a Java containerizer from Google that lets Java developers build containers using build tools like Maven and Gradle.

But that’s not all that is really interesting about Jib: you don’t need to know anything about installing Docker, maintaining Dockerfiles, etc.

As a developer, you only care about the artifact (jar, war, etc.) you will produce, and you don’t have to deal with any of the Docker nonsense (build/push, etc.).

Wow, this is really powerful! But how?

How To Jib

With Jib, you can containerize your Java applications in no time by adding Maven or Gradle plugins to your pom.xml.or build.gradle file. It is that simple. However, in this post I will be covering Maven for demonstration purpose. Let’s get started, then.

We will be using Spring initializr to generate a working Spring Boot project. Source code of our Spring Boot application is available here, and it just prints a "Hello" message when the image is pushed via Jib and the image is run through Docker.

Once we are set up ready with an IDE, we can proceed with the next step.

Setting Up Maven

<plugin>
   <groupId>com.google.cloud.tools</groupId>
   <artifactId>jib-maven-plugin</artifactId>
   <version>2.6.0</version>
   <configuration>
      <from>
         <image>gcr.io/distroless/java:11</image>
      </from>
      <to>
         <image>registry.hub.docker.com/hiashish/spring-boot-jib-image</image>
      </to>
   </configuration>
</plugin>

For Maven, you can paste the above content in your pom.xml plugin section, and you are good to go. But I will try to explain from and image tags here.

<from> Configures the base image to build your application on top of. Typically you don’t need to provide the from tag as, by default, it uses a distroless Java 8 image. However, I have used Java 11, so I have explicitly mentioned that here. Moreover, depending upon your use case, you may want to use a different base image.

<image> This refers to the target image that will pushed to the container registry. I have used the Docker registry, but you can use any cloud provider(ECS, GCR, ACR) container registry.

To use further options with the plugin, you can refer to the documentation.

Setting Credentials For Registry

To push an image, we would need to add registry credentials to maven settings.xml. Since we are just doing a demo, it’s ok to provide credentials this way but avoid using it as it is not secure. You may want to secure credentials as mentioned here.

<server>
    <id>registry.hub.docker.com</id>
    <username>username</username>
    <password>password</password>
</server>

Building An Image

To build an image, we can do it in the following ways.

IDE. For example, in IntelliJ, you can go to maven view of your project, then go under Plugins>jib, then right-click and run the maven build. You may want to create an IntelliJ run configuration that can run maven goals like clean, compile, etc., then push your image.
Using the command line. Just run the below command to build an image of your application. Make sure you have Maven installed first:
```
mvn compile jib:build
```
It will compile, build, and then push your application's image to the configured container registry.

Following is the output:

ashish@MacBook-Air springboot % mvn compile jib:build
[INFO] Scanning for projects…
[INFO]
[INFO] — — — — — — — — — — < com.example:spring-boot-jib > — — — — — — — — — — -
[INFO] Building springboot 0.0.1-SNAPSHOT
[INFO] — — — — — — — — — — — — — — — — [ jar ] — — — — — — — — — — — — — — — — -
[INFO]
[INFO] — — maven-resources-plugin:3.1.0:resources (default-resources) @ spring-boot-jib — -
[INFO] Using ‘UTF-8’ encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO] Copying 0 resource
[INFO]
[INFO] — — maven-compiler-plugin:3.8.1:compile (default-compile) @ spring-boot-jib — -
[INFO] Nothing to compile — all classes are up to date
[INFO]
[INFO] — — jib-maven-plugin:2.6.0:build (default-cli) @ spring-boot-jib — -
[WARNING] ‘mainClass’ configured in ‘maven-jar-plugin’ is not a valid Java class: ${start-class}
[INFO]
[INFO] Containerizing application to registry.hub.docker.com/hiashish/spring-boot-jib-image…
[WARNING] Base image ‘gcr.io/distroless/java:11’ does not use a specific image digest — build may not be reproducible
[INFO] Using credentials from Maven settings file for registry.hub.docker.com/hiashish/spring-boot-jib-image
[INFO] Using base image with digest: sha256:b25c7a4f771209c2899b6c8a24fda89612b5e55200ab14aa10428f60fd5ef1d1
[INFO]
[INFO] Executing tasks:
[INFO]
[INFO] Executing tasks:
[INFO]
[INFO] Executing tasks:
[INFO] [======= ] 25.0% complete
[INFO]
[INFO] Executing tasks:
[INFO] [======= ] 25.0% complete
[INFO] > pushing blob sha256:6508f436f385b3751366f90b6…
[INFO]
[INFO] Executing tasks:
[INFO] [======= ] 25.0% complete
[INFO] > pushing blob sha256:6508f436f385b3751366f90b6…
[INFO] > pushing blob sha256:c5e22041fc97b838b93a2e18d…
[INFO]
[INFO] Executing tasks:
[INFO] [======= ] 25.0% complete
[INFO] > pushing blob sha256:6508f436f385b3751366f90b6…
[INFO] > pushing blob sha256:c5e22041fc97b838b93a2e18d…
[INFO] > pushing blob sha256:b25902383f9ee26808b68ca62…
[INFO]
[INFO] Executing tasks:
[INFO] [======= ] 25.0% complete
[INFO] > pushing blob sha256:6508f436f385b3751366f90b6…
[INFO] > pushing blob sha256:c5e22041fc97b838b93a2e18d…
[INFO] > pushing blob sha256:b25902383f9ee26808b68ca62…
[INFO] > checking base image layer sha256:31eb28996804…
[INFO]
[INFO] Executing tasks:
[INFO] [======== ] 27.8% complete
[INFO] > pushing blob sha256:c5e22041fc97b838b93a2e18d…
[INFO] > pushing blob sha256:b25902383f9ee26808b68ca62…
[INFO] > checking base image layer sha256:31eb28996804…
[INFO]
[INFO] Executing tasks:
[INFO] [========= ] 30.6% complete
[INFO] > pushing blob sha256:c5e22041fc97b838b93a2e18d…
[INFO] > checking base image layer sha256:31eb28996804…
[INFO]
[INFO] Executing tasks:
[INFO] [========== ] 33.3% complete
[INFO] > checking base image layer sha256:31eb28996804…
[INFO]
[INFO] Executing tasks:
[INFO] [=========== ] 35.0% complete
[INFO]
[INFO] Executing tasks:
[INFO]
[INFO]
[INFO]
[INFO] Container entrypoint set to [java, -cp, /app/resources:/app/classes:/app/libs/*, com.jib.example.spring.SpringbootApplication]
[INFO]
[INFO] Built and pushed image as registry.hub.docker.com/hiashish/spring-boot-jib-image
[INFO] Executing tasks:
[INFO] [=========================== ] 91.7% complete
[INFO] > launching layer pushers
[INFO]
[INFO] — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
[INFO] BUILD SUCCESS
[INFO] — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —
[INFO] Total time: 8.746 s
[INFO] Finished at: 2020–11–16T02:34:33+05:30
[INFO] — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Running An Image

We have successfully pushed the image (image name:spring-boot-jib-image) to a Docker registry. Now we can run the image using Docker.

As you can see that our application is running inside a container. Now just run the curl command, and you can see that we got a hello message from our containerized spring-boot application.

curl localhost:8080/hello
Hello From Spring-Boot Jib

Quick Demo

Conclusion

In this article, we have learned how we can containerize our Java applications without Docker. Additionally, with Jib, you can build images using Docker, but that’s not the X factor.

Other benefits of using Jib for your Java applications include that it's super easy to integrate with Java applications, producing faster builds, reproducible builds, community support, etc.

You can go through this link to know about Jib's benefits in detail.

Support me

If you like what you've just read, you can buy me a coffee! :-)

DEV Community: Ashish Choudhary

Monitoring Spring Boot Applications: Part 1

Introduction

What is a JDK Flight Recorder?

JDK Flight Recorder Features

Enabling JDK Flight Recorder

Using Command-line

Using jcmd tool

Using JMC

Conclusion

Introducing the GKE Autopilot Cluster

Getting started with GKE Autopilot cluster

GKE autopilot v/s GKE standard cluster?

Conclusion

What is GitOps, and what are its benefits?

What is GitOps

What are the benefits of GitOps

What is Argo CD?

Conclusion

Spring Boot and Java 16 Records

Introduction

What are Records?

Demystifying Records

Lombok and Records, Friends or Foe?.

Spring Boot and Java Records

Conclusion

Support me

Demystifying Google Container Tool Jib: Java Image Builder

Jib Image Layering

Deep Dive Image Layer

What are Distroless Images?

Why Distroless?

Debugging Distroless Images

Conclusion

Support me

Local Variable Type Inference: Declare var, not war

Where it can be used

Where it cannot be used

What's the benefit?

Conclusion

Support me

Further Reading

Deploying Spring Boot Application on Kubernetes

What you will learn.

What is Docker Desktop?

How to Enable Kubernetes With Docker Desktop for Mac

How to Create a Pod

How to Deploy a Working Spring Boot Application on Kubernetes

How to Monitor and Manage Kubernetes Cluster with Lens IDE

Conclusion

Support me

Further Reading

10 Books Every Java Developer Must Read

Effective Java

Modern Java

Concurrency in practice

Java Module System

Cloud Native Java

Microservices Pattern

Clean code

Head first design pattern

SpringBoot in action

Java performance tunning

Finally Native Reactive JDBC Driver for Oracle Database

Running a Simple Spring Boot Application on OpenShift

Best Book To Understand Latest Java Features

Containerizing Spring Boot Application with Jib

What Is Jib?

How To Jib

Setting Up Maven

Setting Credentials For Registry

Building An Image

Running An Image

Quick Demo

Conclusion

Support me

Further Reading