DEV Community: Laura

Migrating an Springboot Java API: Part 4 - Azure Release

Laura — Sun, 12 Nov 2023 12:38:52 +0000

On the previous post I used AWS Elastic Beanstalk to pull and run 2 dockerized Java APIs in a fully fledged application.
In this guide I will show how I used Azure DevOps release to continously deploy new versions of the APIs into AWS.

Pre-requisites

Azure DevOps agents (I used ubuntu-latest pools)
An AWS account with EB (Elastic Beanstalk) access
Setup AWS Toolkit for Microsoft Azure DevOps

IAM role

In order to allow my Azure releases to deploy new AWS Elastic Beanstalk versions, I created IAM role with the following permission policies:

AdministratorAccess-AWSElasticBeanstalk
AmazonEC2ContainerRegistryFullAccess
EC2InstanceProfileForImageBuilderECRContainerBuilds
AmazonSSMFullAccess
AmazonEC2FullAccess
AWSElasticBeanstalkMulticontainerDocker
AWSElasticBeanstalkRoleECS

Changing the pipelines to include the deployment information

In the previous post I created a deployment folder in my solution repository, so now I changed the existing azure-pipelines.yml to publish the deployment into a different artifact.

trigger:
  - main

resources:
  - repo: self

stages:
  - stage: ReplaceVariables
    displayName: Replace variables
    jobs:
      - job: ReplaceAzureVariables
        displayName: Replace Azure variables
        pool:
          vmImage: ubuntu-latest
        steps:
        - task: replacetokens@5
          displayName: Replace Tokens
          inputs:
            targetFiles: |
              **/application.yml
              **/application.properties
              deployment/**

            encoding: 'auto'
            tokenPattern: 'doublebraces'
            writeBOM: true
            actionOnMissing: 'warn'
            keepToken: false
            actionOnNoFiles: 'continue'
            enableTransforms: false
            enableRecursion: false
            useLegacyPattern: false
            enableTelemetry: false

        - task: CopyFiles@2
          displayName: Copy deployment files
          inputs:
            Contents: 'deployment/**'
            TargetFolder: '$(Build.ArtifactStagingDirectory)'

        - publish: $(Build.ArtifactStagingDirectory)/deployment
          displayName: Publish deployment files
          artifact: deployment

        - task: CopyFiles@2
          displayName: Copy all files 
          inputs:
            Contents: '**'
            TargetFolder: '$(Build.ArtifactStagingDirectory)'

        - publish: $(Build.ArtifactStagingDirectory)
          displayName: Publish all files
          artifact: drop

  - stage: CustomerDockerBuildPublish
    displayName: Customer API
    dependsOn: ReplaceVariables
    jobs:
      - job: Build_and_Push
        displayName: Customer - Build & Push Docker image
        pool:
          vmImage: ubuntu-latest
        steps:
          # Skip source code checkout and reuse sources
          - checkout: none
          # Download the artifact from the ReplaceVariables stage
          - task: DownloadPipelineArtifact@2
            inputs:
              buildType: 'current'
              artifact: drop
              targetPath: '$(Build.SourcesDirectory)'

          - task: Docker@2
            displayName: Customer - Build Customer API Docker image
            inputs:
              command: build
              dockerfile: './Customer.Dockerfile'
              buildContext: '$(Build.SourcesDirectory)'
              repository: $(CUSTOMER_DOCKER_REPOSITORY_NAME)
              tags: |
                $(Build.BuildNumber)

          - task: ECRPushImage@1
            displayName: Customer - Push Admin API Docker image
            inputs:
              awsCredentials: 'my-azure-service-connection'
              regionName: '$(AWS_REGION)'
              imageSource: 'imagename'
              sourceImageName: '$(CUSTOMER_DOCKER_REPOSITORY_NAME)'
              sourceImageTag: '$(Build.BuildNumber)'
              pushTag: '$(Build.BuildNumber)'
              repositoryName: '$(CUSTOMER_DOCKER_REPOSITORY_NAME)'
              logRequest: true
              logResponse: true

  - stage: AdminDockerBuildPublish
    displayName: Admin API
    dependsOn: ReplaceVariables
    jobs:
      - job: Build_and_Push
        displayName: Admin - Build & Push Docker image
        pool:
          vmImage: ubuntu-latest
        steps:
          # Skip source code checkout and reuse sources
          - checkout: none
          # Download the artifact from the ReplaceVariables stage
          - task: DownloadPipelineArtifact@2
            inputs:
              buildType: 'current'
              artifact: drop
              targetPath: '$(Build.SourcesDirectory)'

          - task: Docker@2
            displayName: Admin - Build Admin API Docker image
            inputs:
              command: build
              dockerfile: './Admin.Dockerfile'
              buildContext: '$(Build.SourcesDirectory)'
              repository: $(ADMIN_DOCKER_REPOSITORY_NAME)
              tags: |
                $(Build.BuildNumber)

          - task: ECRPushImage@1
            displayName: Admin - Push Admin API Docker image
            inputs:
              awsCredentials: 'my-azure-service-connection'
              regionName: '$(AWS_REGION)'
              imageSource: 'imagename'
              sourceImageName: '$(ADMIN_DOCKER_REPOSITORY_NAME)'
              sourceImageTag: '$(Build.BuildNumber)'
              pushTag: '$(Build.BuildNumber)'
              repositoryName: '$(ADMIN_DOCKER_REPOSITORY_NAME)'
              logRequest: true
              logResponse: true

Change the release trigger

Then I changed the release to be triggered when new builds from main are successful.

Add Azure DevOps Release

Since we want the image size to be linked to the BuildNumber I have changed the release name configuration to be:

steps:
- task: UsePythonVersion@0
  displayName: 'Use Python 3.7'
  inputs:
    versionSpec: 3.7

- script: 'pip install --upgrade pip'
  workingDirectory: '$(System.DefaultWorkingDirectory)/_MyJavaSolutionAPI/deployment'
  displayName: 'Command Line Script - Install pip'

- script: 'pip install awsebcli --upgrade --user'
  workingDirectory: '$(System.DefaultWorkingDirectory)/_MyJavaSolutionAPI/deployment'
  displayName: 'Command Line Script- Install awsebcli '


- task: AmazonWebServices.aws-vsts-tools.AWSShellScript.AWSShellScript@1
  displayName: 'AWS Shell Script - Elastic Beanstalk init'
  inputs:
    awsCredentials: 'my-aws-azure-service-connection'
    regionName: '$(AWS_REGION)'
    scriptType: inline
    inlineScript: 'eb init $(AWS_BEANSTALK_ENVIRONMENT_NAME) --platform "$(AWS_PLATFORM)" --tags $(AWS_TAGS) --keyname $(AWS_BEANSTALK_KEYNAME_NAME) --region $(AWS_REGION)'
    disableAutoCwd: true
    workingDirectory: '$(System.DefaultWorkingDirectory)/_MyJavaSolutionAPI/deployment'


- task: AmazonWebServices.aws-vsts-tools.AWSShellScript.AWSShellScript@1
  displayName: 'AWS Shell Script - Elastic Beanstalk deploy'
  inputs:
    awsCredentials: 'my-aws-azure-service-connection'
    regionName: '$(AWS_REGION)'
    scriptType: inline
    inlineScript: 'eb deploy $(AWS_BEANSTALK_ENVIRONMENT_NAME) --label "$(Release.ReleaseName)" --message "$(Release.ReleaseDescription)" --process --region $(AWS_REGION)'
    disableAutoCwd: true
    workingDirectory: '$(System.DefaultWorkingDirectory)/_MyJavaSolutionAPI/deployment'

And with that we have a completed CI/CD pipeline in Azure DevOps
This concludes my post series "Migrating an Springboot Java API".
Creating a dockerized version of a Java 1.8 Springboot solution containing 2 APIs, then creating a CI/CD pipeline in Azure DevOps and using AWS Elastic Beanstalk to host and orchestrate the running server.

Migrating an Springboot Java API: Part 3 - AWS ElasticBeanstalk

Laura — Fri, 10 Nov 2023 17:10:29 +0000

On the previous post I showed how to setup an Azure DevOps pipeline to push Docker images into ECR.
In this guide I will show how to use AWS Elastic Beanstalk to pull and run these images in a fully fledged application (with database, EC2 servers, load balancer; all handled by EB)

Pre-requisites

AWS-CLI
EB CLI
An AWS account with the following permissions:
- ECR (Elastic Container Registry)
- ECS (Elastic Container Service)
- EC2 (Elastic Compute Cloud)
- RDS (Relational Database Service)
- EB (Elastic Beanstalk)

IAM role

In order to initialize an EB application, I created IAM role with the following permission policies:

AdministratorAccess-AWSElasticBeanstalk
AmazonEC2ContainerRegistryFullAccess
EC2InstanceProfileForImageBuilderECRContainerBuilds
AmazonSSMFullAccess
AmazonEC2FullAccess
AWSElasticBeanstalkMulticontainerDocker
AWSElasticBeanstalkRoleECS

Optional - push the redis cache to a private ECR repository

It was better for my project to have a locally available version of the dependencies, so I created an powershell script create-local-redis.ps1 to push a new version of the redis image

aws ecr get-login-password --region AWS_REGION | docker login --username AWS --password-stdin AWS_ACCOUNT_ID.dkr.ecr.AWS_REGION.amazonaws.com

docker pull redis:7.2.1

docker tag redis:7.2.1 AWS_ACCOUNT_ID.dkr.ecr.AWS_REGION.amazonaws.com/local-redis:7.2.1

docker push AWS_ACCOUNT_ID.dkr.ecr.AWS_REGION.amazonaws.com/local-redis:7.2.1

Configuration files for Elastic Beanstalk

I used the configuration for EB multicontainer
So I added a deployment/ folder side-by-side with MyJavaSolution with the following:

deployment/
├── create-local-redis.ps1
├── Dockerrun.aws.json
├── .ebextensions/
│ │── db-instance-properties.config
│ │── network-load-balancer.config
│
MyJavaSolution/
├── ...

Dockerrun.aws.json

{
    "AWSEBDockerrunVersion": 2,
    "containerDefinitions": [
        {
            "name": "local-redis",
            "image": "AWS_ACCOUNT_ID.dkr.ecr.AWS_REGION.amazonaws.com/local-redis:7.2.1",
            "portMappings": [
                {
                    "hostPort": 6379,
                    "containerPort": 6379
                }
            ],
            "essential": true,
            "memory": 1024
        },
        {
            "name": "customer_DOCKER_REPOSITORY_NAME",
            "image": "AWS_ACCOUNT_ID.dkr.ecr.AWS_REGION.amazonaws.com/customer_DOCKER_REPOSITORY_NAME:Build.BuildNumber",
            "portMappings": [
                {
                    "hostPort": 9001,
                    "containerPort": 9001
                }
            ],
            "links": [
                "local-redis"
            ],
            "essential": true,
            "memory": 1024
        },
        {
            "name": "ADMIN_DOCKER_REPOSITORY_NAME",
            "image": "AWS_ACCOUNT_ID.dkr.ecr.AWS_REGION.amazonaws.com/ADMIN_DOCKER_REPOSITORY_NAME:Build.BuildNumber",
            "portMappings": [
                {
                    "hostPort": 9002,
                    "containerPort": 9002
                }
            ],
            "links": [
                "local-redis"
            ],
            "essential": true,
            "memory": 1024
        }
    ]
}

db-instance-properties.config

option_settings:  
  # Sets a decoupled database for the connection
  # It can be created from a specific snapshot using DBSnapshotIdentifier
  # If you are happy with the database, you can choose to decouple it via command line later
  aws:rds:dbinstance:
    DBAllocatedStorage: '5'
    DBDeletionPolicy: Retain
    DBInstanceClass: db.t4g.micro    
    DBSnapshotIdentifier: 'DB_INITIAL_SNAPSHOT'
    HasCoupledDatabase: 'true'
    MultiAZDatabase: 'false'
    DBName: DB_NAME
    DBEngine: DB_ENGINE
    DBEngineVersion: DB_ENGINE_VERSION
    DBUser: DB_USERNAME    
    DBPassword: DB_PASSWORD

network-load-balancer.config

option_settings:
  # Set the instance type for EC2 instances to t3.large.
  aws:ec2:instances:
    InstanceTypes: t3.large

  # Set the instance type for Auto Scaling launch configuration to t3.large.
  aws:autoscaling:launchconfiguration:
    InstanceType: t3.large

  # Disable the listener on port 80.
  aws:elbv2:listener:default:
    ListenerEnabled: false

  # Configure Elastic Beanstalk to listen on port 9001.
  aws:elbv2:listener:9001:
      DefaultProcess: default
      ListenerEnabled: 'true'
      Protocol: HTTP
      Rules: null
      SSLCertificateArns: null
      SSLPolicy: null

  # Configure Elastic Beanstalk to listen on port 9002.
  aws:elbv2:listener:9002:
    DefaultProcess: admin
    ListenerEnabled: 'true'
    Protocol: HTTP
    Rules: null
    SSLCertificateArns: null
    SSLPolicy: null

  # Configure default Health endpoint to be Customer health
  aws:elasticbeanstalk:environment:process:default:
    DeregistrationDelay: '20'
    HealthCheckInterval: '15'
    HealthCheckPath: /api/customer/health
    HealthCheckTimeout: '5'
    HealthyThresholdCount: '3'
    MatcherHTTPCode: '200'
    Port: '9001'
    Protocol: HTTP
    StickinessEnabled: 'false'
    StickinessLBCookieDuration: '86400'
    StickinessType: lb_cookie
    UnhealthyThresholdCount: '5'

  # Configure additional Health endpoint to be Admin health
  admin.aws:elasticbeanstalk:environment:process:admin:
    DeregistrationDelay: '20'
    HealthCheckInterval: '15'
    HealthCheckPath: /api/admin/health
    HealthCheckTimeout: '5'
    HealthyThresholdCount: '3'
    MatcherHTTPCode: '200'
    Port: '9002'
    Protocol: HTTP
    StickinessEnabled: 'false'
    StickinessLBCookieDuration: '86400'
    StickinessType: lb_cookie
    UnhealthyThresholdCount: '5'

Inital AWS Elastic Beanstalk setup

Provided the desired images are already in ECR, I first initialized EB after installing AWS and EB CLI with: eb init

Select a default region
1) us-east-1 : US East (N. Virginia)        
2) us-west-1 : US West (N. California)      
3) us-west-2 : US West (Oregon)
4) eu-west-1 : EU (Ireland)
5) eu-central-1 : EU (Frankfurt)
6) ap-south-1 : Asia Pacific (Mumbai)       
7) ap-southeast-1 : Asia Pacific (Singapore)
8) ap-southeast-2 : Asia Pacific (Sydney)   
9) ap-northeast-1 : Asia Pacific (Tokyo)    
10) ap-northeast-2 : Asia Pacific (Seoul)   
11) sa-east-1 : South America (Sao Paulo)   
12) cn-north-1 : China (Beijing)
13) cn-northwest-1 : China (Ningxia)        
14) us-east-2 : US East (Ohio)
15) ca-central-1 : Canada (Central)
16) eu-west-2 : EU (London)
17) eu-west-3 : EU (Paris)
18) eu-north-1 : EU (Stockholm)
19) eu-south-1 : EU (Milano)
20) ap-east-1 : Asia Pacific (Hong Kong)    
21) me-south-1 : Middle East (Bahrain)      
22) il-central-1 : Middle East (Israel)     
23) af-south-1 : Africa (Cape Town)
24) ap-southeast-3 : Asia Pacific (Jakarta)
25) ap-northeast-3 : Asia Pacific (Osaka)

(default is 3): 19


Enter Application Name
(default is "eb_deploy"): MyJavaAPI-newEnv
Application MyJavaAPI-newEnv has been created.

It appears you are using Docker. Is this correct?
(Y/n): y
Select a platform branch.
1) Docker running on 64bit Amazon Linux 2023
2) ECS running on 64bit Amazon Linux 2023
3) Docker running on 64bit Amazon Linux 2
4) ECS running on 64bit Amazon Linux 2
(default is 1): 2 

Cannot setup CodeCommit because there is no Source Control setup, continuing with initialization
Do you want to set up SSH for your instances?
(Y/n): y

Select a keypair.
1) existing_pair
2) [ Create new KeyPair ]
(default is 1): 2


Type a keypair name.
(Default is aws-eb): MyJavaSolutionAPI_pair
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in C:\Users\Username\.ssh\MyJavaSolutionAPI_pair.
Your public key has been saved in C:\Users\Username\.ssh\MyJavaSolutionAPI_pair.pub.
The key fingerprint is:
SHA256:.../te34 MyJavaSolutionAPI_pair
The key's randomart image is:
...
Enter passphrase:
WARNING: Uploaded SSH public key for "MyJavaSolutionAPI_pair" into EC2 for region ...

Create

After the AWS Beanstalk Environment was initialized locally, run eb create to push the initial changes into the server

Enter Environment Name
(default is MyJavaAPI-newEnv): MyJavaAPI-newEnv
Enter DNS CNAME prefix
(default is MyJavaAPI-newEnv): 

Select a load balancer type
1) classic
2) application
3) network
(default is 2): 2


Would you like to enable Spot Fleet requests for this environment? (y/N): n
Creating application version archive "app-231023_153901209577".
Uploading MyJavaAPI/app-231023_153901209577.zip to S3. This may take a while.

If the configuration is applied correctly, then it will create a new EB application and environment, with a coupled RDS database, a EC2 instance, an S3 bucket containing the files, an ECS cluster and all necessary security groups.

Manually deploying a new version on AWS Elastic Beanstalk

Deploy

If the latest build was 20231026.21:
You can change the version in Dockerrun.aws.json and run

eb deploy --label "20231026.21" --message "20231026.21" --process

This will result in a new application version in the server.

Config save

The configuration of a current version can be saved to be reused in different environments.

eb config save --cfg my-api-v2-20231026.21 --tags Environment=newEnv

And with that we have an environment up and running with our 2 dockerized API images.
In the next post of this series I will show how to use Azure DevOps pipelines and release to Continuously Deploy this.

Migrating an Springboot Java API: Part 2 - Azure Build

Laura — Sun, 05 Nov 2023 12:57:25 +0000

On the previous post I dockerized an Java 1.8 Springboot solution.
In this guide I will show how I used Azure DevOps pipelines to build and push images into AWS.

Pre-requisites

Azure DevOps agents (I used ubuntu-latest pools)
An AWS account with ECR (Elastic Container Registry) access
Setup AWS Toolkit for Microsoft Azure DevOps

IAM role

In order to allow my Azure builds to push images into AWS, I created an IAM role with the following permission policies:

AmazonEC2ContainerRegistryFullAccess
AmazonElasticContainerRegistryPublicFullAccess
EC2InstanceProfileForImageBuilderECRContainerBuilds

Changing the hard-coded configurations with variables

In the configuration files of the project, application.yml and application.properties I then substituted it for the variables I created in my Variable groups.
For example, for the Flyway database migration configuration in the application.properties looks like:

#Flyway properties
spring.flyway.enabled=true
spring.flyway.url=jdbc:{{DB_ENGINE}}://{{DB_HOST}}:{{DB_PORT}}/{{DB_NAME}}?characterEncoding=UTF-8
spring.flyway.password={{DB_PASSWORD}}
spring.flyway.user={{DB_USERNAME}}
spring.flyway.schemas={{DB_NAME}}
spring.flyway.locations=classpath:db/migrations
spring.flyway.out-of-order=true
spring.flyway.baseline-on-migrate=true

In the future, the solution will use environment variables instead of replacing them.

Azure pipeline configuration

I then went to Azure -> Pipelines -> New pipeline -> Starter Pipeline
I have used the Variable Groups in Azure Library to hold most of the configuration
In the azure-pipelines.yml file they substitute the fields in the $(...) format. In the code, I added a custom task to replace the fields in the {{...}} format

trigger:
  - main

resources:
  - repo: self

stages:
  - stage: ReplaceVariables
    displayName: Replace variables
    jobs:
      - job: ReplaceAzureVariables
        displayName: Replace Azure variables
        pool:
          vmImage: ubuntu-latest
        steps:
        - task: replacetokens@5
          displayName: Replace Tokens
          inputs:
            targetFiles: |
              **/application.yml
              **/application.properties

            encoding: 'auto'
            tokenPattern: 'doublebraces'
            writeBOM: true
            actionOnMissing: 'warn'
            keepToken: false
            actionOnNoFiles: 'continue'
            enableTransforms: false
            enableRecursion: false
            useLegacyPattern: false
            enableTelemetry: false

        - task: CopyFiles@2
          displayName: Copy all files 
          inputs:
            Contents: '**'
            TargetFolder: '$(Build.ArtifactStagingDirectory)'

        - publish: $(Build.ArtifactStagingDirectory)
          displayName: Publish all files
          artifact: drop

  - stage: CustomerDockerBuildPublish
    displayName: Customer API
    dependsOn: ReplaceVariables
    jobs:
      - job: Build_and_Push
        displayName: Customer - Build & Push Docker image
        pool:
          vmImage: ubuntu-latest
        steps:
          # Skip source code checkout and reuse sources
          - checkout: none
          # Download the artifact from the ReplaceVariables stage
          - task: DownloadPipelineArtifact@2
            inputs:
              buildType: 'current'
              artifact: drop
              targetPath: '$(Build.SourcesDirectory)'

          - task: Docker@2
            displayName: Customer - Build Customer API Docker image
            inputs:
              command: build
              dockerfile: './Customer.Dockerfile'
              buildContext: '$(Build.SourcesDirectory)'
              repository: $(CUSTOMER_DOCKER_REPOSITORY_NAME)
              tags: |
                $(Build.BuildNumber)

          - task: ECRPushImage@1
            displayName: Customer - Push Admin API Docker image
            inputs:
              awsCredentials: 'my-azure-service-connection'
              regionName: '$(AWS_REGION)'
              imageSource: 'imagename'
              sourceImageName: '$(CUSTOMER_DOCKER_REPOSITORY_NAME)'
              sourceImageTag: '$(Build.BuildNumber)'
              pushTag: '$(Build.BuildNumber)'
              repositoryName: '$(CUSTOMER_DOCKER_REPOSITORY_NAME)'
              logRequest: true
              logResponse: true

  - stage: AdminDockerBuildPublish
    displayName: Admin API
    dependsOn: ReplaceVariables
    jobs:
      - job: Build_and_Push
        displayName: Admin - Build & Push Docker image
        pool:
          vmImage: ubuntu-latest
        steps:
          # Skip source code checkout and reuse sources
          - checkout: none
          # Download the artifact from the ReplaceVariables stage
          - task: DownloadPipelineArtifact@2
            inputs:
              buildType: 'current'
              artifact: drop
              targetPath: '$(Build.SourcesDirectory)'

          - task: Docker@2
            displayName: Admin - Build Admin API Docker image
            inputs:
              command: build
              dockerfile: './Admin.Dockerfile'
              buildContext: '$(Build.SourcesDirectory)'
              repository: $(ADMIN_DOCKER_REPOSITORY_NAME)
              tags: |
                $(Build.BuildNumber)

          - task: ECRPushImage@1
            displayName: Admin - Push Admin API Docker image
            inputs:
              awsCredentials: 'my-azure-service-connection'
              regionName: '$(AWS_REGION)'
              imageSource: 'imagename'
              sourceImageName: '$(ADMIN_DOCKER_REPOSITORY_NAME)'
              sourceImageTag: '$(Build.BuildNumber)'
              pushTag: '$(Build.BuildNumber)'
              repositoryName: '$(ADMIN_DOCKER_REPOSITORY_NAME)'
              logRequest: true
              logResponse: true

The pipeline build run should look like this:

Amazon ECR

When the build is successful, it will push a new Docker image to ECR with the Build.BuildNumber as the image tag:

This pipeline is set to run after each commit to main branch. The images are now ready to be deployed into an environment.

In the next post of the series I will show how I used Amazon Elastic Beanstalk to orchestrate and run the API images.

Migrating an Springboot Java API: Part 1 - Docker

Laura — Sat, 04 Nov 2023 20:21:17 +0000

Despite being a primarily .NET Core Azure developer, sometimes we take new challenges. I want to write my process of getting an old Java API from no CI/CD into AWS, in hope that helps devs in a similar situation.

I am aware many things I do in this tutorial can be improved, but being a beginner in AWS and coming from a different tech stack means I will take some decisions which the future me will frown upon, but bear with me ;)

Pre-requisites

Docker
IDE that supports Java and Springboot. I used IntelliJ IDEA
JDK (in my case 1.8)
Springboot
A database (in my case MySql)

The original setup

This application had no CI/CD pipeline. We could access only an AWS EC2 instance with the running APIs amd the source code.

The original setup is a Java 1.8 solution with 3 projects:

MyJavaSolution/
├── pom.xml
│
├── admin/
│ │── src/
│ │ ├── main/
│ │ │ ├── java/
│ │ │ ├── resources/
│ │ │ └──── application.yml
│ │ └── pom.xml
│
├── customer/
│ │── src/
│ │ ├── main/
│ │ │ ├── java/
│ │ │ ├── resources/
│ │ │ └──── application.yml
│ │ └── pom.xml
│
├── common/
│ │── src/
│ │ ├── main/
│ │ │ ├── java/
│ │ │ ├── resources/
│ │ │ └──── application.yml
│ │ └── pom.xml

Both the APIs rely on the common project. And both APIs use a Redis cache (which we will include in the docker-compose)

The objective

The final objective is having a fully functioning CI/CD pipeline and deployment to a cloud provider.

For this series I will use Azure DevOps for the pipeline and AWS as hosting provider.

Part 1 - Dockerizing the project

The first step I did was dockerizing the application. That allows me to reduce the variability between environments and builds, and to access services such as AWS Elastic Beanstalk.

The APIs

Without changing any of the actual solution, I created the following Docker files:

Customer.Dockerfile

# Use a base image with Java 8 and Maven for building
FROM maven:3.6.3-jdk-8 AS builder

WORKDIR /app/common
COPY ./common/pom.xml ./pom.xml
COPY ./common/src ./src

WORKDIR /app/admin
COPY ./admin/pom.xml ./pom.xml
COPY ./admin/src ./src

WORKDIR /app/customer
COPY ./customer/pom.xml ./pom.xml
COPY ./customer/src ./src

WORKDIR /app
COPY ./pom.xml ./pom.xml
RUN mvn dependency:go-offline

RUN mvn package

FROM openjdk:8-jdk-alpine AS runner
WORKDIR /app
COPY --from=builder app/common/target/common-0.0.1-SNAPSHOT.jar ./common.jar
COPY --from=builder app/customer/target/customer-0.0.1-SNAPSHOT.jar ./customer.jar

EXPOSE 9001

CMD ["java", "-jar", "customer.jar"]

Admin.Dockerfile

# Use a base image with Java 8 and Maven for building
FROM maven:3.6.3-jdk-8 AS builder

WORKDIR /app/common
COPY ./common/pom.xml ./pom.xml
COPY ./common/src ./src

WORKDIR /app/admin
COPY ./admin/pom.xml ./pom.xml
COPY ./admin/src ./src

WORKDIR /app/customer
COPY ./customer/pom.xml ./pom.xml
COPY ./customer/src ./src

WORKDIR /app
COPY ./pom.xml ./pom.xml
RUN mvn dependency:go-offline

RUN mvn package

FROM openjdk:8-jdk-alpine AS runner
WORKDIR /app
COPY --from=builder app/common/target/common-0.0.1-SNAPSHOT.jar ./common.jar
COPY --from=builder app/admin/target/admin-0.0.1-SNAPSHOT.jar ./admin.jar

EXPOSE 9002

CMD ["java", "-jar", "admin.jar"]

It might seem a bit strange that I included the customer/ folder in the Admin.Dockerfile and vice-versa but the reason was because the solution pom.xml relied on both to create the .jar files and it the refactoring of this issue was not part of the scope.

The `docker-compose`

After creating the dockerfiles and ensuring they work individually, same as if we running it with Springboot. I then created a docker-compose to ensure me and my team could run it easily:

version: '3'
services:
  local-redis:
    image: redis:7.2.1
    ports:
      - "6379:6379"
  test-customer:
    build:
      context: .
      dockerfile: Customer.Dockerfile
    depends_on:
      - local-redis
    ports:
      - "9001:9001"
  test-admin:
    build:
      context: .
      dockerfile: Admin.Dockerfile
    depends_on:
      - local-redis
    ports:
      - "9002:9002"

Redis cache

Having now included the Redis cache as a Docker container running alongside the APIs, I just needed to change it's reference in the application.xmls.

spring:
  application:
    name: MyJavaSolution
# The redis cache should have the same host name and port as the one defined in the docker-compose.yml
  redis:
    host: local-redis
    port: 6379
    timeout: 5000

And with that we have a fully working, OS-agnostic way of building and running this 2 Java 1.8 APIs.
In the next post of this series I will show how to use Azure DevOps pipelines to build and deploy this.

DEV Community: Laura

Migrating an Springboot Java API: Part 4 - Azure Release

Pre-requisites

IAM role

Changing the pipelines to include the deployment information

Change the release trigger

Add Azure DevOps Release

Migrating an Springboot Java API: Part 3 - AWS ElasticBeanstalk

Pre-requisites

IAM role

Optional - push the redis cache to a private ECR repository

Configuration files for Elastic Beanstalk

Dockerrun.aws.json

db-instance-properties.config

network-load-balancer.config

Inital AWS Elastic Beanstalk setup

Create

Manually deploying a new version on AWS Elastic Beanstalk

Deploy

Config save

Migrating an Springboot Java API: Part 2 - Azure Build

Pre-requisites

IAM role

Changing the hard-coded configurations with variables

Azure pipeline configuration

Amazon ECR

Migrating an Springboot Java API: Part 1 - Docker

Pre-requisites

The original setup

The objective

Part 1 - Dockerizing the project

The APIs

The docker-compose

Redis cache

The `docker-compose`