DEV Community: Devanand Ukalkar

Interacting with AWS S3 using Spring Boot application

Devanand Ukalkar — Sat, 16 Jul 2022 22:07:50 +0000

When it comes to storing objects (files, images..), there are multiple options to choose from. Should I go with keeping files on same/different server as that of application or in database as a BLOB or persist path as record on DB? What about scalability, maintenance, resiliency, decoupling etc.?

With increasing popularity of cloud computing services like storage, fortunately we don't have to worry about all of these anymore. AWS Simple Storage Service (S3) is one of such popular services that you can use to resolve your data storage concerns.

Introduction to AWS S3:

Amazon S3 (Simple Storage Service) is a scalable, high-speed, low-cost web-based service designed for online backup and archiving of data and application programs. It allows to upload, store, and download any type of files up to 5 TB in size. The subscriber has control over the accessibility of data, i.e. privately/publicly accessible.

AWS provides SDKs to manage your objects programmatically. Let's look at steps to get started.

First and foremost thing that you need is AWS account.
Access keys to gain access to storage using AWS storage APIs. You can either use AWS root account's or IAM user account's access keys. Checkout below image to see where these keys are available.
Go to Security Credentials and click on Create Access Key.

Search for S3 and create a bucket with all default values for now.

You need to select AWS S3 region of your choice where you would like to store the data. Please be aware that region affects your AWS bill. More details are available here.

That's enough setup for AWS S3 bucket, let's move on to Spring boot part of this article and get hands dirty with some coding.

I will be using IntelliJ IDEA for this project with Spring Initiliazr plugin & Maven as build tool.

Create a new project and choose "Spring Initiliazr" from Generators section.

Specify project properties as per your need and create project.

Add AWS S3 SDK dependency in pom.xml. There are few other dependencies needed for this project. GitHub repository link is shared at the end of this article.



<dependency>
    <groupId>com.amazonaws</groupId>
    <artifactId>aws-java-sdk-s3</artifactId>
    <version>1.12.239</version>
</dependency>

Add below parameters in application.properties under resources folder.

We will be dividing this into 3 parts.

Configuration class which will be responsible to authenticate application with AWS S3 client.
Service class responsible to interact with S3 bucket.
Controller class containing APIs to perform file operations.

Configuration class:



package com.springbootstorage.awss3.configuration;

import com.amazonaws.auth.AWSStaticCredentialsProvider;
import com.amazonaws.auth.BasicAWSCredentials;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class S3ClientConfiguration {

    @Value("${access.key.id}")
    @Getter
    private String accessKeyId;

    @Value("${access.key.secret}")
    @Getter
    private String accessKeSecret;

    @Value("${s3.region.name}")
    @Getter
    private String bucketRegion;

    @Bean
    public AmazonS3 getAwsS3Client() {
        BasicAWSCredentials basicAWSCredentials = new BasicAWSCredentials(accessKeyId, accessKeSecret);
        return AmazonS3ClientBuilder
                .standard()
                .withCredentials(new AWSStaticCredentialsProvider(basicAWSCredentials))
                .withRegion(bucketRegion)
                .build();
    }
}

Service Class:



package com.springbootstorage.awss3.service;

import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.model.*;
import lombok.Data;
import org.apache.commons.io.FileUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

@Data
@Service
public class S3FileService {

    @Value("${s3.bucket.name}")
    private String s3BucketName;
    private final String DOWNLOAD_PATH = "D:\\S3Download\\";
    private final String UPLOAD_PATH = "E:\\";

    @Autowired
    private AmazonS3 amazonS3;

    // List all objects in the bucket
    public List<String> listAllObjects(String s3BucketName) {

        List<String> listOfObjects = new ArrayList<>();

        ObjectListing objectListing = amazonS3.listObjects(s3BucketName);
        for (S3ObjectSummary objectSummary : objectListing.getObjectSummaries()) {
            listOfObjects.add("FileName: " + objectSummary.getKey() +
                    " | " + "LastModified: " + objectSummary.getLastModified() +
                    " | " + "Size: " + objectSummary.getSize());
        }

        return listOfObjects;
    }

    // Downloading object from the bucket
    public String downloadObject(String s3BucketName, String objectName) {
        S3Object s3Object = amazonS3.getObject(s3BucketName, objectName);
        S3ObjectInputStream inputStream = s3Object.getObjectContent();
        try {
            FileUtils.copyInputStreamToFile(inputStream, new File( DOWNLOAD_PATH + objectName));
            return DOWNLOAD_PATH + objectName +  " Downloaded Successfully!";
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    // Upload object to the bucket
    public PutObjectResult uploadObject(String s3BucketName, String objectName, File objectToUpload) {
        return amazonS3.putObject(s3BucketName, objectName, objectToUpload);
    }

    public void deleteObject(String bucketName, String objectName) {
        amazonS3.deleteObject(bucketName, objectName);
    }
}

Controller class:



package com.springbootstorage.awss3.controller;

import com.amazonaws.services.s3.model.PutObjectResult;
import com.springbootstorage.awss3.service.S3FileService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.File;
import java.util.List;

@RestController
@RequestMapping("/api/v1")
public class S3Controller {

    @Autowired
    private S3FileService s3FileService;

    // List all files in the bucket
    @GetMapping("/listAllFiles")
    public String listAllFilesInBucket() {
        List<String> files = s3FileService.listAllObjects(s3FileService.getS3BucketName());
        StringBuilder allFiles = new StringBuilder();
        allFiles.append("****************************************\n");
        allFiles.append("List of Files available in bucket ").append(s3FileService.getS3BucketName());
        allFiles.append("\n****************************************\n");
        for (String filename : files)
            allFiles.append(files).append("\n");
        return allFiles.toString();
    }

    @PostMapping("/upload/{fileToUpload}")
    public PutObjectResult uploadFiletoBucket(@PathVariable String fileToUpload) {
        return s3FileService.uploadObject(s3FileService.getS3BucketName(), fileToUpload, new File(s3FileService.getUPLOAD_PATH()+ fileToUpload));
    }

    @PostMapping("/download/{fileToDownload}")
    public String downloadFileFromBucket(@PathVariable String fileToDownload) {
        return s3FileService.downloadObject(s3FileService.getS3BucketName(), fileToDownload);
    }

    @PostMapping("/delete/{fileToDelete}")
    public String deleteFileFromBucket(@PathVariable String fileToDelete) {
        s3FileService.deleteObject(s3FileService.getS3BucketName(), fileToDelete);
        return fileToDelete + " has been deleted successfully from " + s3FileService.getS3BucketName();
    }
}

Lets start Spring boot application and test this API for Listing, uploading, downloading and deleting objects on S3 bucket now.

We have below 4 endpoints to perform these operations.



http://localhost:9090/api/v1/listAllFiles
http://localhost:9090/api/v1/upload/
http://localhost:9090/api/v1/download/
http://localhost:9090/api/v1/delete/

Upload objects to S3 bucket.



curl -XPOST http://localhost:9090/api/v1/upload/sample1.jpg
curl -XPOST http://localhost:9090/api/v1/upload/sample2.jpg
curl -XPOST http://localhost:9090/api/v1/upload/employees.json

List objects in bucket.

curl http://localhost:9090/api/v1/listAllFiles

Download objects from bucket.

curl -XPOST http://localhost:9090/api/v1/download/employees.json

Delete objects from bucket.

curl -XPOST http://localhost:9090/api/v1/delete/employees.json

You can manage creation/deletion of buckets programmatically as well. Please check out more such examples on this link

You can find code for this project on below given GitHub repository.

https://github.com/devanandukalkar/SpringBootAwsS3

That's it for this one. Hope you enjoyed reading it. Keep Learning!! Cheers!

FastJSON - Convert POJO to/from JSON

Devanand Ukalkar — Thu, 14 Jul 2022 14:35:34 +0000

Fastjson is a lightweight Java library created by Alibaba. It can be used to convert POJO (Plain Old Java Object) into their JSON representation & convert a JSON string to an equivalent POJO. Fastjson can work with arbitrary Java objects including pre-existing objects that you do not have source-code of.

Let's dive straight into the example to look at how this library provides easy APIs to convert Java objects to / from JSON.

We will create one simple Maven project with following dependencies for FastJson and Lombok(for getters/setters) in pom.xml file.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>fast-json-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.7</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

</project>

Lets write simple POJO Employee Class and a Main class to convert it into JSON.

JSON.toJSONString() method helps to serialize Employee object to JSON string.

Employee.java

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

@Data
public class Employee {

    @JSONField(name = "EmployeeId")
    private Integer id;

    @JSONField(name = "EmployeeName")
    private String name;

    @JSONField(name = "EmployeeLocation")
    private String location;

    @JSONField(name = "EmployeeSalary")
    private Double salary;

    public Employee(Integer id, String name, String location, Double salary) {
        this.id = id;
        this.name = name;
        this.location = location;
        this.salary = salary;
    }
}

Main.java

import com.alibaba.fastjson2.JSON;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<Employee> employeeList = new ArrayList<>();

        employeeList.add(new Employee(1, "Stephen Hawking", "UK", 1000.00));
        employeeList.add(new Employee(2, "Albert Einstein", "Germany", 2000.00));

        // Convert Employee object to JSON
        String jsonString = JSON.toJSONString(employeeList);

        System.out.println(jsonString);
    }
}

Output:

The JSON output is customizable with control over ordering of key-value pair. You will just need to pass an argument as ordinal = <nth order> to @JSONField

 @JSONField(name = "EmployeeLocation", ordinal = 4)
    private String location;

 @JSONField(name = "EmployeeSalary", ordinal = 3)
    private Double Salary;

if you compare the previous output with this one, the key's positions are ordered as specified.

You can choose to ignore some of the fields with serialize=false parameter.

@JSONField(name = "EmployeeId", serialize = false)
    private Integer id;

You can choose date formatting with format="MM/dd/YYYY" parameter.

@JSONField(name = "EmployeeDoJ", format = "MM/dd/YYYY", ordinal = 5)
    private Date dateOfJoining;

Now, lets parse JSON to Java object. We will look at converting a JSON String, array and file to an object.

Converting JSON String to Object can be done using JSON.parseObject(jsonToConvert, Employee.class);. One of the things to note here is that, the Keys missing in JSON strings will be defaulted to "false". Additionally, if you choose not to deserialize any specific field, you can specify parameter as "deserialize=false" in the @JSONField annotation.

@JSONField(name = "EmployeeId", serialize = false, deserialize = false)
    private Integer id;

// Convert JSON String to Java Object
String jsonToConvert = "{\"EmployeeName\":\"Stephen Hawking\",\"EmployeeSalary\":1000.0,\"EmployeeLocation\":\"UK\"}";
System.out.println("JSON to Convert ==> " + jsonToConvert + "\n");
Employee employeeObj = JSON.parseObject(jsonToConvert, Employee.class);
System.out.println("Converted to Employee Object ==> " + employeeObj);

JSON array to Java object using JSON.parseArray(jsonArrayToConvert, Employee.class);

String jsonArrayToConvert = "[{\"EmployeeName\":\"Stephen Hawking\",\"EmployeeSalary\":1000.0,\"EmployeeLocation\":\"UK\"},{\"EmployeeName\":\"Albert Einstein\",\"EmployeeSalary\":2000.0,\"EmployeeLocation\":\"Germany\"}]";
System.out.println("JSON Array to Convert ==> " + jsonArrayToConvert + "\n");
List<Employee> employees = JSON.parseArray(jsonArrayToConvert, Employee.class);
System.out.println("Converted to Employee Objects ==> " + employees);

JSON file to Java Object --> FastJson bit lacks in direct JSON file support, it needs some extra code to to read from JSON file.

JSON File:

// Convert JSON File to Java Object
try (Stream<String> lines = Files.lines(Paths.get("employees.json"))) {
    String jsonContent = lines.collect(Collectors.joining());
    List<Employee> empList = JSON.parseArray(jsonContent, Employee.class);
    System.out.println("Converted to Java Object ==> " + empList);
} catch (IndexOutOfBoundsException | IOException ex) {
    ex.printStackTrace();
}

You can checkout more examples on below GitHub Repository.
https://github.com/eugenp/tutorials/tree/master/json-modules/json-2

Leave your reactions and comments below if you found this information useful! Cheers!!

Monitoring Microservices with Spring Boot Admin

Devanand Ukalkar — Sun, 10 Jul 2022 09:31:39 +0000

The microservices enable the rapid, frequent and reliable delivery of large, complex applications. Monitoring, managing or troubleshooting poor performing microservice can be tedious task sometime, especially if you have to go to multiple places to look at what is happening under the hood. Be it looking for behavior of an application through log file, threads, heap memory etc. And you would certainly like all these things at one place for quick monitoring of your spring boot applications.

Although Spring Boot Actuator can do the magic for you if you have single app to look after. When you have multiple applications to monitor, Spring Boot Admin is a great choice!

Spring Boot Admin Server is an application used to manage and monitor your Microservice applications. CodeCentric team had developed Spring Boot Admin UI to manage your Spring Boot application actuator endpoints.

Each microservice acts as a client and has to register to Spring boot admin server. Behind the curtain, admin server leverages application's actuator endpoints to gather all the data.

Lets look at what is needed to build a Spring Boot Admin server.

Go to https://start.spring.io/ and Generate a starter project with mentioned dependencies.

Maven



        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
        </dependency>

Add the @EnableAdminServer annotation to your main application class. The @EnableAdminServer annotation will turn your spring boot application to Admin Server and monitor all other microservices.

Define application name and port in application.properties



spring.application.name=adminserver
server.port=9090

And that's all about it! Your Spring Boot Admin server is ready to run and serve the clients connecting to it.

Tomcat server will be started on the port 9090 as specified. You can launch Spring Boot Admin UI by browsing http://localhost:9090

Now that our Admin server is all setup, lets write couple of client applications to place on monitoring.

You will need to add below dependencies to pom.xml file.



        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
        </dependency>

I have created two REST API applications for demo. We need to setup these as a client to connect to admin server.

We need to add few properties to application.properties file as given below.

Note: From Spring Boot 2 and above, actuator endpoints except health and info are restricted. That why we are exposing all the endpoints by specifying the properties explicitly.



# Application
spring.application.name=Demo API
server.port=8080

# Spring boot admin server 
spring.boot.admin.client.url=http://localhost:9090

# Actuator endpoints properties
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always

# To monitor log file on admin server
logging.file.name=demo_api.log
logging.logback.rollingpolicy.max-history=5
logging.logback.rollingpolicy.max-file-size=10MB

Once client applications are started, they will be registered to admin server.

You can now see the applications being monitored on Spring Boot Admin UI Wallboard with their overall status.

Applications tab will show you the details on number of applications up/down, overall status, lets you filter the apps etc.

Journal tab will give you the audit details on startup/shutdown of a particular application.

Lets look at what other granular details are being provided for each of these applications.

You can look at overall health of an application instance.

Add metrics as per your requirement.

Details on system environment
Application beans

Configuration details and scheduled tasks if any

You can monitor and download logs of an application

You can set the logger level as well

JVM related details on Thread and Heap dump.

URI mappings of an application

Cache details of an application

As you can see, we have all the details about an application at one place now.

Lets look at few other modules provided by Spring Boot Admin.

We had exposed all the actuator endpoints to admin server which in turn will expose all the sensitive information about an application as well. It becomes pivotal to secure admin UI and have only authorized personnel look at it.

You can refer https://codecentric.github.io/spring-boot-admin/current/#securing-spring-boot-admin to secure admin UI.

Notification about a particular event in an application is also of great importance to avoid eye on the glass monitoring. Spring boot admin notifications module provides lot of options to notify user via Email, MS teams, Slack etc.

Checkout https://codecentric.github.io/spring-boot-admin/current/#_notifications for more details.

I hope you enjoyed reading about Spring Boot Admin in this article. Leave your reactions and comments below if you found this useful. Keep Learning!

Want to run Python in web browser? PyScript is here!

Devanand Ukalkar — Wed, 06 Jul 2022 12:14:52 +0000

PyScript is a brand new framework that allows users to create Python applications in the browser within HTML code itself. It is powered with Pyodide and WASM.

Pyodide is a Python distribution for the browser and Node.js based on WebAssembly. (Source)

On technical level, PyScript is built with TypeScript, Svelte Framework, Python, JavaScript, Tailwind CSS and bundled with rollup.js

Some of the core components of PyScript involve (Source):

Python in the browser: Enable drop-in content, external file hosting, and application hosting without the reliance on server-side configuration

Python ecosystem: Run many popular packages of Python and the scientific stack (such as numpy, pandas, scikit-learn, and more)

Python with JavaScript: Bi-directional communication between Python and Javascript objects and namespaces

Environment management: Allow users to define what packages and files to include for the page code to run

Visual application development: Use readily available curated UI components, such as buttons, containers, text boxes, and more

Flexible framework: A flexible framework that can be leveraged to create and share new pluggable and extensible components directly in Python

You might be thinking that, is it going to replace the behemoth JavaScript which powers 95% of the websites?...Not really! Currently, PyScript is an experimental project in its alpha phase with lots of issues from its usability to slowness. So it's clearly not recommended to use in Production at the moment.

Lets look at what is needed to use PyScript in HTML code.

You will need to add below links in <head> tag.

<link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
<script defer src="https://pyscript.net/alpha/pyscript.js"></script>

You can then use PyScript components in your html page. Some of the elements PyScript currently implements are:

<py-script>: can be used to define python code that is executable within the web page. The element itself is not rendered to the page and is only used to add logic.

<py-env> : manages project dependencies similar to pip tool.

<py-env>
    - matplotlib
    - numpy
</py-env>

<py-repl>: creates a REPL component that is rendered to the page as a code editor and allows users to write executable code.

You can also use your custom python modules. Below is the example.

<py-env>
    - matplotlib
    - numpy
    - paths:
        - src/data.py
</py-env>

There are many more tags that you can find on their github repository.

Let's write some code to demonstrate few examples of above tags.

1. Say Hello to PyScript

<!DOCTYPE html>
<html lang="en">
<head>
  <title>Hello, PyScript!</title>
  <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
</head>
<body>
  <py-script>print("Hello, PyScript!")</py-script>
  <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
</body>
</html>

Output:

2. Build your own REPL

<!DOCTYPE html>
<html>

<head>
    <title>PyScript REPL</title>
    <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
    <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
</head>

<body>
    <div class="text-center">
        <br>
        <h1><b>PyScript REPL</b></h1><br>
        <pre>Tip: Press Shift+ENTER to evaluate cell</pre>
        <br>
    </div>
    <div>
        <py-repl id="my-repl" auto-generate="true"></py-repl>
    </div>

</body>

</html>

Output:

3. Plot graph using matplotlib and numpy

plot.html

<!DOCTYPE html>
<html>

<head>
    <title>PyScript Plot</title>
    <link rel="stylesheet" href="https://pyscript.net/alpha/pyscript.css" />
    <script defer src="https://pyscript.net/alpha/pyscript.js"></script>
    <py-env>
        - matplotlib
        - numpy
        - paths:
            - /pyscript_plot.py
    </py-env>
</head>

<body>
    <br>
    <h1><b>PyScript Plot</h1><br>
    <div id="plot"></div>
    <py-script output="plot">
from matplotlib import pyplot as plt
from pyscript_plot import get_values

x, y = get_values()
fig, ax = plt.subplots()
ax.scatter(x, y)
fig
    </py-script>

</body>

</html>

pyscript_plot.py

import numpy as np
import math 

def get_values():
    x = np.arange(0, math.pi*2, 0.05)
    y = np.sin(x)
    return x, y

Output:

You can find more examples on below link.

https://github.com/pyscript/pyscript/tree/main/examples

The entire project indeed looks promising. Given that its in alpha phase right now, We will have to wait and see how this framework takes shape and accepted within developers community.

Keep Learning...Cheers! 😃

Deploy Spring Boot application to AWS Elastic Beanstalk and RDS

Devanand Ukalkar — Fri, 01 Jul 2022 19:48:28 +0000

Are you looking to deploy your application to AWS without hassle of managing infrastructure?

With AWS Elastic Beanstalk, you can quickly deploy and manage applications in the AWS Cloud without worrying about the infrastructure that runs those applications.

In this article, we will be looking at steps to deploy spring boot application with MySQL Database to AWS Elastic Beanstalk and RDS.
Lets get started!

First of all, We need to setup MySQL database using AWS RDS. I wrote an article on how to use RDS to provision a MySQL database. Please follow below link for the same.

https://dev.to/devanandukalkar/how-to-create-database-using-aws-rds-meh

Once your database is ready, add mysql-connector dependency to pom.xml file.

Update the properties file with details from provisioned database.
Go to AWS console and search for "Elastic Beanstalk".

Click on "Create Application" to start the deployment wizard.

Type in your application name & platform needed to run it (There are many other options to choose from).

Under "Source code origin" choose local file and upload the jar for your application & click Create Application.

Your environment could take few minutes to deploy.

Once the environment is created, use given link to access your application. The "Health" on the snapshot says severe because AWS process checks if there is a response from root of your application. Make sure your WebApp or API does not throws 5xx error on the root path.
You can always reupload your code with section given as "Upload and deploy". That's about it!

Please leave your reactions and comment below if you found this short article helpful!

Guide to Dockerize your Spring Boot application with MySQL database

Devanand Ukalkar — Thu, 30 Jun 2022 21:27:47 +0000

So, you want to build a Java Spring Boot application and run it inside a Docker container? This article will provide you step by step guide to build MySQL Database & spring boot application images to run it in a container.

I will be using AWS EC2 Linux instance in this article, but all the commands will be similar on other OS except the installation part.

First step is to have docker installed on the machine that you are using. Follow steps on below link for installation.

https://docs.docker.com/engine/install/ubuntu/

Once Docker is installation is finished, check if its installed correctly.

docker -v

docker info

I am using MySQL database in this application, so we will have to first create docker network for the MySQL database.
Pull the MySQL image from docker hub and check if its available locally.

docker pull mysql:5.7

docker images

Create docker network for Spring boot application to communicate with MySQL database.

docker network create springboot-mysql-net

Run the MySQL container in the network and wait for few minutes.

docker run -it --name mysqldb --network=springboot-mysql-net -e MYSQL_ROOT_PASSWORD=1234 -e MYSQL_DATABASE=expensetracker -e MYSQL_USER=sys -e MYSQL_PASSWORD=1234 -d mysql:5.7

Now that MySQL container is running, Lets check if the database is created using interactive mode. To connect to mysqldb container in interactive mode, you can use below command with few initial characters from the container id.

Syntax: docker exec -it <container-id> bash

docker exec -it 81e7 bash
mysql -u sys -p 1234
show databases;

With MySql database running in container now, lets move on to update the application properties to connect to this database.

# MySQL properties
spring.datasource.url=jdbc:mysql://mysqldb:3306/expensetracker
spring.datasource.username=sys
spring.datasource.password=1234

Now we need to build docker image from the spring boot application jar using Dockerfile.

Run below command to build the docker image.

docker build -t springbootmysql .

So, We have our mysql database container running and we have built docker image for the application, lets start the spring boot container on the same network as that of the database one.

docker run --network=springboot-mysql-net --name springboot-container -p 8080:8080 -d springbootmysql

As you can see, our spring boot application is now running in a container.
Lets see how we can push this image to docker hub. You will first need to create your account https://hub.docker.com/
Once account is created, login to docker hub using docker login command.
Once login is successful, you can use below command(change name as per your login & image) to push the image to docker hub.

docker push devanandukalkar/springbootmysql

Hopefully, you find this article useful. Let me know your feedback in comments section.

How to provision database using AWS RDS for your next application

Devanand Ukalkar — Tue, 28 Jun 2022 12:22:06 +0000

Amazon Relational Database Service (RDS) is a distributed relational database service by Amazon Web Services. It is a web service running "in the cloud" designed to simplify the setup, operation, and scaling of a relational database for use in applications.

This article will guide you through the simple steps to provision a production grade database for your application within matter of minutes. Lets get started!

First obvious step is to create AWS account to avail the services.
Once you have your account ready, Search for RDS on AWS homepage

Scroll bit down and click on "Create Database" button.

Choose "Standard Create" as database creation method & Select MySQL from the Engine options (You can choose database as per your need).

Select MySQL version and template as "Free Tier"

Move to Settings section and enter details such as your database name in "DB Instance Identifier", username and password.

Leave all other default options and hit on "Create database" at the bottom

Database creation would take up to 10 mins. The status would be changed to available once its provisioned.

Once database is created, you will see database related details such as Endpoint & port, network, security etc.

Your database is not yet available to connect publicly. the Security group needs to have a rule to allow database to be accessed over the internet. Using "Security group rules", add following mentioned inbound rules to your database endpoint.

You are now ready to test your database connections!

In this case, Open MySQL Workbench and test the connection using the database Endpoint, port, username and password given at the time of provisioning. Yoohooo! It's all ready to be used by your application now!

How I cleared Microsoft Azure AZ-204 in one month

Devanand Ukalkar — Fri, 28 Jan 2022 09:35:09 +0000

AZ-204: Developing Solutions for Microsoft Azure focuses on design, development, deployment, maintenance and monitoring of scalable solutions on Azure. There is no pre-requisite for this certification. But if you complete AZ-900: Azure Fundamentals before, your learning process will speed up in terms of understanding some of the general concepts of Microsoft Azure. The exam covers each of these aspects with varying weightage. Below are the core skills that Microsoft has outlined on their learning portal.

Develop Azure compute solutions (25-30%)
Develop for Azure storage (15-20%)
Implement Azure security (20-25%)
Monitor, troubleshoot, and optimize Azure solutions (15-20%)
Connect to and consume Azure services and third-party services (15-20%)

Detailed exam skills outline can be found here.

Just to give you a glimpse of what Azure services will need to be studied from exam perspective.

Azure Virtual Machines
Azure Functions
Azure Storage Account
Azure Web Apps
Azure Logic Apps
Azure Cosmo DB
Azure Container Registry/Docker
Azure Key Vault
Azure Active Directory
Azure Authentication(OAuth 2.0), Security
Azure Service Bus/Queue, Azure Storage queues
Azure Event Grid, Event Hub
Azure API management
Azure Cache for Redis
Azure ARM Templates
Application Insights
Azure Monitor
Azure CLI, Powershell
Azure Batch
Azure Search

The exam will require a bit of experience with programming languages supported by Azure (e.g. C#, Python, Java, Node.js). Although the tutorials present out there are mostly using C# for development. But it should not matter much as there are Azure SDKs for each of these supported languages which you can use to develop a solution.

How I prepared for the exam:

I started with Scott Duffy's AZ-204 Developing for Microsoft Azure Exam Prep course on Udemy. This course covers practical guide to develop each Azure services outlined for the exam. It can be completed within a week or two(depending on your speed).

The second course that I referred to was from Alan Rodrigues on YouTube (link). This course is bit more on hours but provides comprehensive knowledge. Alan has developed solutions for each of those Azure services from scratch using C#/.Net in the tutorials.

If you are short on time, I would suggest to take first course by Scott Duffy. But If you really want to learn it in detail, I would really recommend to take Alan Rodrigues's course on YouTube.

As the course covers a lot, it's almost impossible to grasp it by just watching the videos. You must practice developing these solutions using your preferred choice of programming language. That way, it will be easier to understand nitty-gritty concepts which would ultimately help you in exam.

I had practiced azure development using Python. The SDKs can be found on this GitHub link. There are many built in extensions for these Azure services in Visual Studio Code, please make sure to utilize them.

Additionally, you could read Microsoft's official documentation and make use of their learning portal. Details can be found here.

Practice Questions:

Practicing questions should make about 30% of your preparation time. This is very important, as you would get to know the variety of questions that will be asked and how to manage time during examination.

There are about 2 case studies given in the exam with 10-15 questions based on the same. It could take time to read the case study and understand the problem. Trick is to not read entire problem. Instead, read question first and then head back to related specific portion of the case study. This will help in save time during exam.

You must get good grasp on Azure CLI, powershell commands & related arguments, as there are many questions related to completing the command by filling in the blanks. There are few questions on completing the unfinished code as well (e.g importing libraries or invoking methods/classes)

I would recommend below 2 resources to practice questions for AZ-204.

Practice tests by Skillcertpro
Practice tests by Whizlabs

In fact, even if you complete just the first one, it should be more than enough to clear the examination.

Key is to have as much hands on experience as possible. I hope this will help you to prepare for examination.

Best of luck and Let me know your questions in comment section.

Check out my verified badge:
https://www.credly.com/badges/05857a22-73a8-4ec2-a438-c5ee8733d6ee