When we decide to create a microservice, we may have a clear view of what we want to do, but deciding how we are going to do it may be more complex than anticipated. In this section, we will guide you through the required initial steps. First, we may need to set up a set of tools, which we will use later for managing our projects' files and dependencies to edit our code.

Then, we will take advantage of using Spring Initializr, a service provided by Spring to easily create new Spring Boot applications. Since Spring Initializr generates a project for a chosen build system, in our case Maven, we will learn how to use it effectively. Finally, we may need an IDE that allows us to help in our developer tasks, from debugging to refactoring, IntelliJ IDEA will be our choice for this.

Microservices, if exposed as web services, either JSON or XML, need to have the corresponding HTTP server capabilities. As well as managing resources and connections to databases, they may consume other services, or even publish data through messages queues.

If you have worked with these kinds of applications before, you may remember how complex they were in order to configure and set up with probably dozens of XML files and properties and in many cases a lot of boilerplate code that initialized many of these systems.

Spring, through Spring Boot, provides a framework that will drastically reduce the boilerplate code and autoconfigure most of the system that we need to use.

Let's review the different components that we will use to create microservices.

Now that we know something more about building microservices within Spring Boot, we need to package and run our service. This will teach us how to package a Spring Boot application.

Then, we will analyze the difference between packaging, using JARs or WARs.

Finally, we learn how to run the package applications, and how to creating self-executables JARs.

We can package the application using the Maven lifecycle phase package, either using the IntelliJ Maven projects window or from the command line.

When we create a Spring Boot application, we may need to use configuration values, things that we want to externalize from the application code itself, or that we may want to change without affecting the main code.

First, we will make some changes in our service and review the different methods to configure the application. Then, we will understand what Spring Expression Language is, and how we can use application profiles. Finally, we will apply our knowledge of configuration to create some conditional beans.

There is a time in any application that we may need to have a configurable value, something that we can define outside our main code and that can easily change...

Now we have a set of tools that we understand and will boost our productivity when creating microservices. When we create new microservices, instead of starting from scratch, we have to learn how to use Spring Initializr and how to customize it for our needs. We understand now what the component scan is and how by using components we can decouple our microservices implementation and we are ready to configure our microservices using the flexible Spring Configuration.

Now it's time to create more advanced microservices. For starters, we will do a deep dive into creating RESTFul APIs in the next chapter. There, we will learn how we can handle requests, and produce responses, or even handle errors, and how we can use HTTP verbs and status to produce our ubiquitous language for the users of our API.