In this fast-paced intro, you’ll learn the essentials of MySQL, including its:

• history
• advantages
• disadvantages
• use-cases
• and companies, which successfully use it to ship their products.

And one more thing before we start. This article is a continuation of a series describing the Top 8 Most Popular Databases. If you would like to learn more about other solutions, then I highly recommend you bookmark that article and come back to it later.

Explainer Animation

If you enjoy whiteboard animations, then right here you can find a video version for this article:

If you find this content useful, please leave a subscription  😉

MySQL Genesis

So as the first thing in our introduction, let’s take a while to learn more about MySQL’s history.

MySQL was developed by a Swedish company called MySQL AB, which was founded in 1995 by Allan Larsson, David Axmark, and Michael Widenius. The name is a combination of Michael’s daughter’s name- My– and the abbreviation for Structured Query Language (SQL).

The development began in 1994, and the goal was to create a fast, reliable, and easy-to-use database system that could be used in a variety of applications. And although there were already a number of other database management systems available, many of these systems were complex to install and use, and they often required specialized skills and expertise to manage effectively. On the other hand, available open-source solutions were not as widely used as they are today, and many organizations were hesitant to adopt them due to concerns about their performance, support, and reliability.

As a result, MySQL quickly gained popularity among developers and organizations looking for an alternative to commercial database systems. Its success helped to pave the way for other open-source database systems, and it played a significant role in the growth of the open-source software movement as a whole.

Lastly, it’s worth mentioning that MySQL AB was bought by Sun Microsystems, which is now an Oracle Corporation (since 2010).

What Is MySQL and How Does It Work?

And although the previous chapter is a great MySQL introduction, let’s learn a bit more about it.

If I would have to answer the question “what is MySQL?” in one sentence, then I’d say that it is an open-source relational database management system. Moreover, according to the StackOverflow Developer Survey 2022, it’s the most popular RDBMS in the world. It is fast, reliable, and easy to use, making it an attractive choice for developers and organizations of all sizes.

MySQL is written in C++ and C and it was initially created from mSQL (aka Mini SQL), which is provided for non-commercial use. And although it gained a new SQL interface, the API remained the same making it easy to migrate from mSQL.

As a relational database, MySQL stores and organizes data in tables, which are grouped into databases. Each table consists of rows and columns. Rows represent individual pieces of data, while columns represent the different attributes of that data. And in order to query and manipulate the data from the database, we can use SQL queries. When it comes to storage, MySQL stores data in memory and on disk combining together performance and durability.

Finally, MySQL includes a number of other tools and features that make it easier to manage the database. These include utilities for security, performance tuning, backup, and recovery.

MySQL & LAMP

It’s worth mentioning in our MySQL introduction, that MySQL is a part of the LAMP stack.

LAMP is nothing else than an acronym for a proven set of technologies developers use to build websites and web applications:

• Linux for the operating system
• Apache HTTP Server
• MySQL for the relational database management system
• PHP/Perl/Python programming language

Not to mention you’re reading this article thanks to MySQL (used by WordPress).

MySQL Advantages

So, at this point, we know what is MySQL and as the next step, let’s figure out what it brings to the table:

• MySQL is easy to use. It is known for being easy to install and use. Moreover, it has a simple and intuitive interface. This makes it not only a great choice for beginners, and less experienced teams, but also can bring lower costs for many companies.
• It’s open-source with a large and active community. MySQL is the most popular database in the world. And this advantage, combined with tons of documentation, blogs, and other resources available online, speeds up its integration, management, and debugging.
• Performance. And even though it might not be the best choice for large data sets, it’s still a multi-user and multi-threaded SQL server, which can handle millions of requests per day.
• Transactions support. Transactions, are an important feature of MySQL and allow us to ensure that the database remains in a consistent state, even if one of the operations fails.
• Flexibility. Lastly, MySQL supports multiple storage engines, which allows users to choose the best storage engine for their specific needs. Additionally, it supports a wide range of programming languages, making it easy to integrate into web-based applications and other systems.

MySQL Disadvantages

And as with everything, MySQL has some drawbacks, as well:

• Scaling complexity. Although MySQL can actually handle a lot of traffic, the scaling process requires manually sharding the data across multiple servers and configuring the servers to work together.
• Lack of certain security features. MySQL does not include certain security features, such as data masking and data classification, which are available in other database management systems.
• Limited support for distributed transactions. It does not have native support for distributed transactions.
• Commercial editions might be pricey. Although the open-source version of MySQL is free, the commercial editions of MySQL are licensed and can be expensive.

MySQL Use Cases

As the next thing in our MySQL introduction, let’s see when it can be a good choice:

• Web-based applications. MySQL is often used as the database backend for web-based applications. (And as mentioned previously, it’s a part of a LAMP stack).
• E-commerce. It’s a common choice for e-commerce platforms, due to its ability to handle large amounts of data and transactions support.
• Mobile applications. MySQL might be used as the database backend for mobile applications, as well.
• Internet Of Things. It can be used to store and manage data from IoT devices, such as sensors and connected devices.

Companies Using MySQL

Lastly, let’s see a couple of companies, which use MySQL Database to deliver their products and services.

First of all, WordPress uses MySQL as its default database management system. Without it, you wouldn’t read this article 😉

Moreover, GitHub uses MySQL as its core data store. BBC makes use of the MySQL InnoDB Cluster and Uber claims that MySQL engine as the low-level storage layer has allowed them to very quickly build a robust system.

Of course, when we look at the list, we can find other known companies, like:

• Spotify
• YouTube
• Facebook
• Sony
• Airbnb and many more.

If you’d like to learn more about other companies, then you can check out the official customers’ list.

MySQL Introduction Conclusion

And that’s all for this MySQL introduction, which is a continuation of a Top 8 Databases series. Together, we learned what is MySQL, its advantages, and disadvantages, as well, as its history and use cases.

If you are interested in Spring Boot, then you might want to check out my other articles with MySQL in practice and others under the MySQL Tag.

Finally, as always am happy to answer any questions and hear your thoughts. See you in the comments section!

The post MySQL Essentials: A Fast-Paced Introduction appeared first on Codersee blog- Kotlin on the backend.

In this article, we will take a look at the 8 most popular databases and their key features, as well as common use cases.

So, no matter whether you are a database administrator, programmer, or simply would like to learn more about the different databases available, this article will provide you with all the necessary information to start with.

Doodly Animation

If you find this content useful, please leave a thumb up, or a sub. This way you can help me, so that I can help you 😉

What Does “The Most Popular Databases” Mean?

Well, before we start I wanna make sure that we are on the same page when referring to the “most popular”.

Depending on who wrote the article, this term can have various meanings. For some, it will be the frequency of Google searches. For others, it may be data provided by the https://db-engines.com page.

And for the purpose of this blog post, I decided to use the Stack Overflow Developer Survey 2022 results, which present, as follows:

In the next chapters, I will walk you through each of the 8 most popular databases shortly.

Please keep in mind that this article is a general overview and expect that more thorough continuations will be added in the upcoming weeks 🙂

MySQL Database

With that being said, let’s start with the winner- MySQL.

It’s an open-source relational database management system (aka RDBMS). It was created in 1994 by the Swedish company MySQL AB (which was later acquired by Sun Microsystems and then by Oracle Corporation). Originally, it was developed as a proprietary database system but later it was open-sourced under the GNU General Public License.

Advantages:

• It’s free and open-source, so it can be a great choice for smaller companies and organizations preferring to cut costs.
• Moreover, MySQL is widely supported by web hosting providers, which means that it can be easily integrated with web-based applications.
• Additionally, it has a low learning curve and a simple and intuitive user interface, so it is not only a great choice for beginners but also for less experienced teams.
• Finally, a large and active community of users and developers means a lot of online resources and support available.

Disadvantages:

• First of all, it is not designed for applications that require real-time data processing or high availability. And technically- this is not a drawback, but rather something you should be aware of.
• Whatsoever, MySQL is hard to scale and not intended for large amounts of data.
• Lastly, it does not have built-in support for full-text search or geospatial data and some advanced features that are available in other database systems.

As I mentioned above, I will create a separate blog post about the king of the most popular databases. But for now, I can invite you to check out my other how-to guides with MySQL:

• Deploy Kotlin Spring Boot App with MySQL on Kubernetes
• Spring Boot on Google GKE with Cloud SQL and Kotlin

PostgreSQL (aka Postgres)

Nextly, let’s take a look at the second place with a 3% difference- PostgreSQL (also known as Postgres).

It was created in 1986 by a team of researchers at the University of California and is a powerful and open-source object-relational database management system. PostgreSQL is a highly popular and widely used DBMS, known for its flexibility, reliability, and performance.

Advantages:

• Just like MySQL, PostgreSQL is open-source, free to use, and has a large, active community.
• It is highly reliable and performs well even under heavy workloads. This makes it a good choice for applications that require high availability and scalability.
• Moreover, Postgres comes with support for a lot of features and capabilities out of the box. For example triggers, stored procedures, and multi-row transactions.

Disadvantages:

• Firstly, PostgreSQL may not be as widely supported or compatible with technologies, as some other database systems.
• Secondly, it may not be as fast or scalable as other database management systems, such as NoSQL databases. And whereas it works well for large datasets, it is not the speed demon.
• Whatsoever, Postgres is a pretty complex system, so it might be a bit difficult to learn.

And just like previously, please expect new articles to come. But, again, if you would like to learn backend development with Kotlin and Postgres, then I can recommend:

• REST API With Spring WebFlux and Kotlin Course
• other tutorials on how to use it with Spring Boot, or Ktor

SQLite

As the next step, let’s take a while to the no 3 in the most popular databases summary- SQLite.

SQLite is an embedded SQL database engine. The main difference between it and most of SQL databases is that it is self-contained and does not run a separate server process. To put it simply- it’s a library, which reads and writes directly to plain disk files.

It was created in 2000 by Dwayne Richard Hipp using a C programming language and since then, it become the most deployed database engine- used, among others of top web browsers.

Advantages:

• First of all, SQLite is a really lightweight database and it can be successfully used in low-memory environments. With all features enabled, its size can be as little as 750KiB.
• Additionally, the database file format is portable and can be migrated between 32-bit ad 64-bit systems.
• Moreover, SQLite is easy to learn and requires zero configuration, which makes it a great choice for beginners (and not only!)
• Finally, it is really fast and can bring much better performance, than the filesystem.

Disadvantages:

• Firstly- it’s not suitable for client/server applications. Although it can work over the network, the filesystem latency might be an issue.
• Secondly (and lastly), SQLite is not a good choice for high-volume websites or environments demanding high concurrency. Whereas it does not have a limit for concurrent reads, only one writer can write at any instant in time.

MongoDB (aka Mongo)

And the prize for 4th place in our most popular databases ranking goes to MongoDB.

MongoDB is an open-source document-oriented database. It was created in 2009 by MongoDB Inc., which makes it not only the first NoSQL representative in the ranking but also the youngest one (so far). In contrast to previous examples, MongoDB is an example of a NoSQL database, so instead of tables and rows, Mongo stores JSON-like documents, which are organized in collections.

Advantages:

• First of all, Mongo was built with environments demanding high performance and scalability in mind.
• Secondly, it’s flexible. MongoDB does not require you to define a schema for your collections (SQL tables counterparts), which can help you reduce the time spent on schema changes. Moreover, it can be a great choice everywhere, where a schema is hard to define.
• Finally, just like MySQL and Postgres, MongoDB is widely supported and really easy to learn.

Disadvantages:

• No out-of-the-box support for joins. Unlike relational databases, Mongo by design does not support joins between collections, so if you have to work with highly connected data sets, then it might not be the best choice.
• Moreover, MongoDB documents cannot exceed 16MB.
• Lastly, the lack of joins oftentimes leads to data duplication, which may become troublesome to maintain in the future.

If you would like to learn Mongo in practice, then check out my practical guides about MongoDB with Spring Boot, Ktor, and Micronaut.

Microsoft SQL Server

Following, the 5th position on the most popular databases list is taken by Microsoft SQL Server.

It was developed by Microsoft and first released in 1989 and is another relational database in our ranking. Microsoft SQL Server lets us communicate using T-SQL (Transact-SQL), which is an extension of SQL bringing additional features, like functions, or local variables. Whatsoever, it comes with an entire range of products, which we can optionally configure together to make it a really powerful tool.

Advantages:

• Firstly, Microsoft SQL Server has really good support and documentation.
• Additionally, it’s relatively easy to set up and use.
• Whatsoever, SQL Server provides a range of security features to protect against unauthorized access to the data and ensure data integrity.
• Lastly, a strong point is data recovery in case anything happens.

Disadvantages:

• First of all, pricing. And although there is a free option available, Enterprise or Standard editions are pretty expensive.
• Secondly, compatibility. Prior to the SQL Server 2017, it could be run on Windows-based servers, but this is the first version, which can be deployed on Linux.
• Lastly, it may require additional Microsoft software purchases to fully make use of it in your case.

Redis

And the 6th most popular database of 2022 is Redis.

It was created by Salvatore Sanfilippo, also known as antirez, in 2009, which makes it a relatively young database in our summary.

Redis is an open-source, in-memory data structure store that is commonly used as a database, cache, and message broker. It is known for its high performance, flexibility, and scalability, making it a popular choice for a wide range of applications. Whatsoever, it is oftentimes used in conjunction with Microservices and containers, to support the needs of modern, distributed applications.

Advantages:

• As the first one- Redis is an in-memory data store, which results in much higher data processing, than disk-based databases.
• Additionally, it’s highly scalable and can be easily expanded to support the growing needs of our application.
• Lastly, Redis is an open-source project with a large community and a huge amount of online resources to use and learn from. Moreover, it is compatible and pretty easy to use with most of the popular frameworks.

Disadvantages:

• So the first advantage is the disadvantage, as well. The in-memory data store is actually faster, but we have to keep in mind that it is more expensive.
• Moreover, it is a key-value store (like a dictionary), which means that the application(s) connecting to Redis have to be aware of the structure, which requires additional config.
• Lastly, Redis is doing fine when dealing with key-based operations, but is not that efficient, when it comes to searching through the data set.

If you would like to learn more about it in detail, then check out my more detailed article: Redis Database Explained

MariaDB

As the one before last in the most popular databases list, let’s see what exactly MariaDB is.

First of all, MariaDB is a fork of the MySQL DBMS, created by the original developers of MySQL in response to the acquisition of MySQL by Oracle Corporation. The acquisition raised concerns among many users and developers about the future direction of the MySQL project, which resulted in MariaDB being released in 2009.

It’s known for its performance, reliability, and ease of use, and is used by many organizations around the world. Moreover, it is designed to be backward-compatible with MySQL and can be used as a drop-in replacement for it in most cases.

Advantages:

• Firstly, MariaDB is known for its performance and reliability.
• Additionally, it is an open-source project with a large and active community of users and developers. And I know that this argument repeats often in this article. But trust me- a wealth of resources, such as documentation and tutorials, available online comes with plenty of other perks.
• Thirdly, as mentioned above it can be used as a MySQL drop-in replacement in most cases. This allows companies to replace the database without changing the other tools. However, please remember that this is not always the case and sometimes may require additional work.
• And lastly, it is widely supported by various programming languages and frameworks.

Disadvantages:

• As the first one, some of the MySQL Enterprise Edition features are not available out of the box. And although this can be done through plugins, this is an additional, independent tool we have to incorporate.
• Whatsoever, migrating from MySQL may result in additional adjustments and config.
• And as the last thing- the support may be pretty expensive.

Elasticsearch

And finally, we come to the last position in the top 8 most popular databases of 2022- Elasticsearch.

Elasticsearch is an open-source, full-text search and analytics engine created by Shay Banon in 2010.

It is designed to be scalable and flexible, making it a popular choice for building search and data analysis applications. Moreover, it’s based on the Lucene search engine library and provides a RESTful API for interacting with the data. Elasticsearch is known for its powerful search and analytics capabilities, and can be used to search, analyze, and visualize data from a variety of sources, including structured, unstructured, and time-series data.

Advantages:

• Elasticsearch is an open-source project, supported by a large and active community of users.
• Similarly, it’s compatible with plenty of programming languages and frameworks, which helps in its implementation.
• Lastly, it is a highly scalable search and analytics engine, which is intended for fast full-text searches. Thus, it can be a great solution for website searches.

Disadvantages:

• Elasticsearch may not be as fast or efficient as some other search and analytics platforms in certain scenarios- for example, a large amount of data.
• Moreover, it is more difficult to learn compared to similar tools. But this comes with being more powerful, as well.
• Lastly, Elasticsearch should not be used as primary storage.

The Most Popular Databases Summary

And that’s all for this article about the 8 most popular databases. As I already mentioned, this is the initial, bird’s-eye view post and you can expect more detailed articles to come.

Let me know your thoughts in the comments section below!

The post A Quick Intro To The 8 Most Popular Databases appeared first on Codersee blog- Kotlin on the backend.

Last week, we’ve learned how to deploy the Spring Boot application to Google Kubernetes Engine and connect it to the CloudSQL instance of MySQL database.

This time, I want to show you a more universal approach- deploying the Kotlin Spring Boot App with MySQL directly on Kubernetes. This approach requires a little more setup, but thanks to that, we gain more independence- we can easily migrate our environment between Kubernetes managed services providers (or to self-hosted k8s).

2. Prerequisites

To follow the tutorial you need the following prerequisites:

• kubectl (Kubernetes CLI to manage a cluster)
• minikube (local Kubernetes, making it easy to learn and develop for Kubernetes)
• docker (containerization tool)

3. Create Spring Boot Application

In this tutorial, I’d like to begin with developing our Spring Boot app first (but it’s also OK to start with the Kubernetes part).

3.1. Imports

As the first step, let’s add the following dependencies:

    implementation("org.springframework.boot:spring-boot-starter-web")
    implementation("org.springframework.boot:spring-boot-starter-data-jpa")
    runtimeOnly("mysql:mysql-connector-java")

Please remember, that you can see the full build.gradle configuration here.

3.2. Configure Application Properties

After we’ve successfully added the import, let’s head to the application.yaml file and configure it as follows:

spring:
  datasource:
    url: jdbc:mysql://mysql-svc:3306/${DB_NAME}?useSSL=false
    username: ${DB_USERNAME}
    password: ${DB_PASSWORD}
  jpa:
    hibernate:
      ddl-auto: update
    databasePlatform: "org.hibernate.dialect.MySQL5InnoDBDialect"

As you might have noticed, we are setting the MySQL connection details here. Please remember, that the host (mysql-svc) has to match the MySQL Kubernetes service name (we will set it up later). The ddl-auto property set to update will automatically export the schema DDL to the database when the SessionFactory is created (to put it simply, it will create the database schema based on our Spring Boot entities).

3.2. Create Model

As the next step, let’s add two classes to our project. User class, which will be the user entity we will persist in our MySQL database:

@Entity
class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long = 0,

    @Column
    val name: String
)

As you can see, it is a simple class containing two fields- autogenerated id and a name.

Nextly, let’s add UserRequest, which will be bound to the bodies of the web requests later:

class UserRequest(
    val name: String
)

3.4. Create Repository

After that, we can create the UserRepository interface, which will be used to perform the operations on the database:

interface UserRepository : CrudRepository<User, Long>

3.4. Create Service

As the next step, let’s implement the UserService class as follows:

@Service
class UserService(
    private val userRepository: UserRepository
) {

    fun saveUser(request: UserRequest): User =
        userRepository.save(
            User(
                name = request.name
            )
        )

    fun findAllUsers(): MutableIterable<User> =
        userRepository.findAll()
}

These two functions will be responsible for creating and getting the list of all users.

3.5. Implement Controllers

Finally, we can set up our controllers responsible for handling the incoming requests. Let’s start by adding the ApiStatusController:

@RestController
@RequestMapping("/api/status")
class ApiStatusController {
    @GetMapping
    fun getStatus(): ResponseEntity = ResponseEntity.ok("OK")
}

The GET /api/status endpoint will be used later to configure our K8s Pod’s readiness and liveness probes.

As the last step, let’s create the UserController class:

@RestController
@RequestMapping("/api/user")
class UserController(
    private val userService: UserService
) {
    @PostMapping
    fun createUser(@RequestBody request: UserRequest): ResponseEntity {
        val user = userService.saveUser(request)

        return ResponseEntity.ok(user)
    }

    @GetMapping
    fun findAllUsers(): ResponseEntity<MutableIterable> {
        val users = userService.findAllUsers()

        return ResponseEntity.ok(users)
    }
}

These two functions will be responsible for responding to the POST and GET requests to the /api/user endpoint. As you can see, we are using here the UserRequest class, we’ve implemented earlier as the createUser method parameter.

3.6. Build the JAR

Let’s build the jar with the Gradle wrapper:

./gradlew clean build -x test

Please notice “-x test” flag here. Testing goes beyond the main topic of this tutorial, so I’ve decided to go with this workaround for now.

3.7. Create Dockerfile

Nextly, let’s create the Dockerfile:

FROM openjdk
WORKDIR /work
COPY ./build/libs/k8s-mysql-0.0.1-SNAPSHOT.jar app.jar
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/work/app.jar"]

4. Deploy to Kubernetes

In this part, we are going to prepare the Kubernetes environment for our Spring Boot application. To keep this article as pragmatic as possible, we won’t spend too much time on the details here. If you would like to get a better understanding of these topics, please, let me know about it and I will prepare more materials about it.

4.1. Create Secrets

As the first step, let’s create the secrets.yaml file and put the configuration for our secrets here:

apiVersion: v1
kind: Secret
data:
  root-password: <BASE64-ENCODED-PASSWORD>
  database-name: <BASE64-ENCODED-DB-NAME>
  user-username: <BASE64-ENCODED-DB-USERNAME>
  user-password: <BASE64-ENCODED-DB-PASSWORD>
metadata:
  name: mysql-secret

In simple words, secrets let us store and manage sensitive information in a secure manner.
Please also notice that all of the values should be encoded as base 64. You can do that for instance on this website.

4.2. Create Persistent Volume

As the next step, let’s create the deployment-mysql.yaml file:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mysql-pv
  labels:
    type: local
spec:
  storageClassName: standard
  capacity:
    storage: 250Mi
  accessModes:
    - ReadWriteOnce
  hostPath:
    path: "/mnt/data"
  persistentVolumeReclaimPolicy: Retain
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mysql-pvc
  labels:
    app: spring-boot-mysql
spec:
  storageClassName: standard
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 250Mi

A PersistentVolume (PV) is a piece of the storage in the cluster, while the PersistentVolumeClaim (PVC) is the request for storage.

4.3. Create MySQL Deployment

Deployments allow us to provide updates for our Pods and ReplicaSets in a declarative manner. To configure the MySQL database let’s add the following config to our deployment-mysql.yaml file:

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mysql-deployment
  labels:
    app: spring-boot-mysql
spec:
  selector:
    matchLabels:
      app: spring-boot-mysql
      tier: mysql
  strategy:
    type: Recreate
  template:
    metadata:
      labels:
        app: spring-boot-mysql
        tier: mysql
    spec:
      containers:
        - image: mysql:5.7
          name: mysql
          env:
            - name: MYSQL_ROOT_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: root-password
            - name: MYSQL_DATABASE
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: database-name
            - name: MYSQL_USER
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-username
            - name: MYSQL_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-password
          ports:
            - containerPort: 3306
              name: mysql
          volumeMounts:
            - name: mysql-persistent-storage
              mountPath: /var/lib/mysql
      volumes:
        - name: mysql-persistent-storage
          persistentVolumeClaim:
            claimName: mysql-pvc

As you can see above, we are passing our 4 secrets to the MySQL container as the environment variables- these values will be used for our connection.

4.4. Create MySQL Service

Finally, we need to expose the database for our Spring Boot application. Let’s do that by creating the service-mysql.yaml file and putting the following confirugation:

apiVersion: v1
kind: Service
metadata:
  name: mysql-svc
  labels:
    app: spring-boot-mysql
spec:
  ports:
    - port: 3306
  selector:
    app: spring-boot-mysql
    tier: mysql
  clusterIP: None

Please notice, that the name property of the metadata has to match the value from the application.yaml file of the Spring Boot project.

4.5. Create Spring Boot Deployment

After the MySQL part is correctly set up, we can configure the resources for our application. Let’s start by creating the deployment-spring.yaml file:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-boot-deployment
  labels:
    app: spring-boot-mysql
spec:
  replicas: 2
  selector:
    matchLabels:
      app: spring-boot-mysql
  template:
    metadata:
      labels:
        app: spring-boot-mysql
    spec:
      containers:
        - image: spring-boot:0.0.1
          name: spring-boot-container
          imagePullPolicy: Never 
          ports:
            - containerPort: 8080
          readinessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 10
            failureThreshold: 5
          livenessProbe:
            httpGet:
              port: 8080
              path: /api/status
            initialDelaySeconds: 10
            failureThreshold: 5
          env:
            - name: DB_NAME
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: database-name
            - name: DB_USERNAME
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-username
            - name: DB_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: mysql-secret
                  key: user-password

Please notice one important thing here- in the next steps, I will show you how to use the local Spring Boot Docker image of our application. That’s why we’ve set the imagePullPolicy property to Never.

4.6. Create Spring Boot Service

The last thing, we need to configure for our backend is a Service. Let’s create then the service-spring.yaml file:

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

4.7. Apply and Verify Resources

Finally, we can deploy our configurations to the Kubernetes cluster. As the first step, let’s start a local Kubernetes cluster with minikube:

minikube start --vm-driver=virtualbox

As I’ve mentioned in step 4.5, in this tutorial, we will use the local docker image without pushing to any remote image repository.

To do that, let’s reuse the Docker daemon from Minikube:

eval $(minikube docker-env)

Please keep in mind, that this is a Unix command. If you are using Windows OS, please check out this StackOverflow topic.

Nextly, let’s build our docker image:

docker build -t spring-boot:0.0.1 .

Please remember, that the tag has to match the value from our Spring Boot deployment.

As the last step, let’s apply our configurations:

kubectl apply -f k8s/secrets.yaml
kubectl apply -f k8s/deployment-mysql.yaml 
kubectl apply -f k8s/service-mysql.yaml
kubectl apply -f k8s/deployment-spring.yaml
kubectl apply -f k8s/service-spring.yaml

To verify if everything is ready, we can use the following commands:

kubectl get svc
kubectl get deployments
kubectl get pods
kubectl get secrets

5. Verify the Application

To verify, if the application is working correctly, we will have to get the IP address of the running cluster and the port of the Spring Boot Service.

We can obtain the IP address in two ways: either by minikube or using kubectl command:

minikube ip
//result
192.168.39.87


kubectl cluster-info
//result
Kubernetes master is running at https://192.168.39.87:8443

To get the port of the application, let’s invoke the following command:

kubectl get svc spring-boot-svc 

//Example response
NAME              TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
spring-boot-svc   LoadBalancer   10.107.222.166        8080:30264/TCP   33s

As you can see above, the desired port of the application will be 30264. Please keep in mind, that this value will be different each time we will create the Service.

Finally, let’s create the user using the curl command:

curl -X POST -H "Content-Type: application/json" \
  --data '{"name":"Piotr"}' \
  192.168.39.87:30264/api/user

//response
{"id":1,"name":"Piotr"}

As the last step, let’s get the list of all users:

curl 192.168.39.87:30264/api/user

//Response:
[{"id":1,"name":"Piotr"}]

6. Summary

And that would be all for this article. In this step by step guide, we’ve learned how to deploy the Spring Boot and MySQL application on Kubernetes.

I am really aware that this topic is quite complex and requires an understanding of several concepts. The main goal for this tutorial was to walk you through the whole process without diving too much into the details. If you find anything in this article confusing or have any additional questions/suggestions, I will be more than happy if you would let me know about it (you can do that by our fan page, group, or a contact form).

To see the whole project, please visit this GitHub repository.

The post Deploy Kotlin Spring Boot App with MySQL on Kubernetes appeared first on Codersee blog- Kotlin on the backend.

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.