Java Runtimes and Azure Container Apps Workshop

git clone <your_repo_url>

java -version
mvn --version
docker --version
az --version
git --version
curl --version
jq --version

cd <your_repo_url>
mvn install

[INFO] ------------------------------------------------------------------------
[INFO] Reactor Summary:
[INFO]
[INFO] Azure Container Apps and Java Runtimes Workshop 1.0.0-SNAPSHOT SUCCESS
[INFO] Azure Container Apps and Java Runtimes Workshop :: Micronaut 1.0.0-SNAPSHOT SUCCESS
[INFO] Azure Container Apps and Java Runtimes Workshop :: Springboot 1.0.0-SNAPSHOT  SUCCESS
[INFO] Azure Container Apps and Java Runtimes Workshop :: Quarkus 1.0.0-SNAPSHOT SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  16.097 s
[INFO] Finished at: 2022-10-07T09:46:16+02:00
[INFO] ------------------------------------------------------------------------

package io.containerapps.javaruntime.workshop.quarkus;

import jakarta.ws.rs.DefaultValue;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;
import java.lang.System.Logger;
import java.time.Duration;
import java.time.Instant;
import java.util.HashMap;
import java.util.List;

import static java.lang.System.Logger.Level.INFO;
import static java.lang.invoke.MethodHandles.lookup;

@Path("/quarkus")
@Produces(MediaType.TEXT_PLAIN)
public class QuarkusResource {

    private static final Logger LOGGER = System.getLogger(lookup().lookupClass().getName());

    private final StatisticsRepository repository;

    public QuarkusResource(StatisticsRepository statisticsRepository) {
        this.repository = statisticsRepository;
    }
}

@GET
public String hello() {
    LOGGER.log(INFO, "Quarkus: hello");
    return "Quarkus: hello";
}

@GET
@Path("/cpu")
public String cpu(@QueryParam("iterations") @DefaultValue("10") Long iterations,
                  @QueryParam("db") @DefaultValue("false") Boolean db,
                  @QueryParam("desc") String desc) {
    LOGGER.log(INFO, "Quarkus: cpu: {0} {1} with desc {2}", iterations, db, desc);
    Long iterationsDone = iterations;

    Instant start = Instant.now();
    if (iterations == null) {
        iterations = 20000L;
    } else {
        iterations *= 20000;
    }
    while (iterations > 0) {
        if (iterations % 20000 == 0) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException ie) {
            }
        }
        iterations--;
    }

    if (db) {
        Statistics statistics = new Statistics();
        statistics.type = Type.CPU;
        statistics.parameter = iterations.toString();
        statistics.duration = Duration.between(start, Instant.now());
        statistics.description = desc;
        repository.persist(statistics);
    }

    String msg = "Quarkus: CPU consumption is done with " + iterationsDone + " iterations in " + Duration.between(start, Instant.now()).getNano() + " nano-seconds.";
    if (db) {
        msg += " The result is persisted in the database.";
    }
    return msg;
}

@GET
@Path("/memory")
public String memory(@QueryParam("bites") @DefaultValue("10") Integer bites,
                     @QueryParam("db") @DefaultValue("false") Boolean db,
                     @QueryParam("desc") String desc) {
    LOGGER.log(INFO, "Quarkus: memory: {0} {1} with desc {2}", bites, db, desc);

    Instant start = Instant.now();
    if (bites == null) {
        bites = 1;
    }
    HashMap hunger = new HashMap<>();
    for (int i = 0; i < bites * 1024 * 1024; i += 8192) {
        byte[] bytes = new byte[8192];
        hunger.put(i, bytes);
        for (int j = 0; j < 8192; j++) {
            bytes[j] = '0';
        }
    }

    if (db) {
        Statistics statistics = new Statistics();
        statistics.type = Type.MEMORY;
        statistics.parameter = bites.toString();
        statistics.duration = Duration.between(start, Instant.now());
        statistics.description = desc;
        repository.persist(statistics);
    }

    String msg = "Quarkus: Memory consumption is done with " + bites + " bites in " + Duration.between(start, Instant.now()).getNano() + " nano-seconds.";
    if (db) {
        msg += " The result is persisted in the database.";
    }
    return msg;
}

@GET
@Path("/stats")
@Produces(MediaType.APPLICATION_JSON)
public List<Statistics> stats() {
    LOGGER.log(INFO, "Quarkus: retrieving statistics");
    return Statistics.findAll().list();
}

package io.containerapps.javaruntime.workshop.quarkus;

import io.quarkus.hibernate.orm.panache.PanacheEntity;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import java.time.Duration;
import java.time.Instant;

@Entity
@Table(name = "Statistics_Quarkus")
public class Statistics extends PanacheEntity {

    @Column(name = "done_at")
    public Instant doneAt = Instant.now();
    public Framework framework = Framework.QUARKUS;
    public Type type;
    public String parameter;
    public Duration duration;
    public String description;
}

enum Type {
    CPU, MEMORY
}

enum Framework {
    QUARKUS, MICRONAUT, SPRINGBOOT
}

package io.containerapps.javaruntime.workshop.quarkus;

import io.quarkus.hibernate.orm.panache.PanacheRepository;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.transaction.Transactional;

@ApplicationScoped
@Transactional
public class StatisticsRepository implements PanacheRepository<Statistics> {
}

mvn compile

quarkus.http.port=8701

package io.containerapps.javaruntime.workshop.quarkus;

import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.Test;

import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.*;

@QuarkusTest
public class QuarkusResourceTest {
}

@Test
public void testHelloEndpoint() {
    given()
      .when().get("/quarkus")
      .then()
        .statusCode(200)
        .body(is("Quarkus: hello"));
}

@Test
public void testCpuWithDBAndDescEndpoint() {
    given().param("iterations", 1).param("db", true).param("desc", "Java17")
      .when().get("/quarkus/cpu")
      .then()
        .statusCode(200)
        .body(startsWith("Quarkus: CPU consumption is done with"))
        .body(not(containsString("Java17")))
        .body(endsWith("The result is persisted in the database."));
}

@Test
public void testMemoryWithDBAndDescEndpoint() {
    given().param("bites", 1).param("db", true).param("desc", "Java17")
      .when().get("/quarkus/memory")
      .then()
        .statusCode(200)
        .body(startsWith("Quarkus: Memory consumption is done with"))
        .body(not(containsString("Java17")))
        .body(endsWith("The result is persisted in the database."));
}

@Test
public void testStats() {
    given()
      .when().get("/quarkus/stats")
      .then()
        .statusCode(200);
}

mvn test

[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

mvn quarkus:dev

curl 'localhost:8701/quarkus'

curl 'localhost:8701/quarkus/cpu?iterations=10&db=true&desc=java17'

curl 'localhost:8701/quarkus/memory?bites=10&db=true&desc=java17'

curl 'localhost:8701/quarkus/cpu?iterations=50'
curl 'localhost:8701/quarkus/cpu?iterations=100'
curl 'localhost:8701/quarkus/cpu?iterations=100&db=true'

curl 'localhost:8701/quarkus/memory?bites=50'
curl 'localhost:8701/quarkus/memory?bites=100'
curl 'localhost:8701/quarkus/memory?bites=100&db=true'

curl 'localhost:8701/quarkus/stats'

# or if you have "jq" installed you can make it prettier with
# curl 'localhost:8701/quarkus/stats' | jq

package io.containerapps.javaruntime.workshop.micronaut;

import io.micronaut.runtime.Micronaut;

public class Application {

    public static void main(String[] args) {
        Micronaut.run(Application.class, args);
    }
}

package io.containerapps.javaruntime.workshop.micronaut;

import io.micronaut.http.MediaType;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.QueryValue;

import java.lang.System.Logger;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import static java.lang.System.Logger.Level.INFO;
import static java.lang.invoke.MethodHandles.lookup;

@Controller("/micronaut")
public class MicronautResource {

    private static final Logger LOGGER = System.getLogger(lookup().lookupClass().getName());

    private final StatisticsRepository repository;

    public MicronautResource(StatisticsRepository statisticsRepository) {
        this.repository = statisticsRepository;
    }
}

@Get(produces = MediaType.TEXT_PLAIN)
public String hello() {
    LOGGER.log(INFO, "Micronaut: hello");
    return "Micronaut: hello";
}

@Get(uri = "/cpu", produces = MediaType.TEXT_PLAIN)
public String cpu(@QueryValue(value = "iterations", defaultValue = "10") Long iterations,
                  @QueryValue(value = "db", defaultValue = "false") Boolean db,
                  @QueryValue(value = "desc", defaultValue = "") String desc) {
    LOGGER.log(INFO, "Micronaut: cpu: {0} {1} with desc {2}", iterations, db, desc);
    Long iterationsDone = iterations;

    Instant start = Instant.now();
    if (iterations == null) {
        iterations = 20000L;
    } else {
        iterations *= 20000;
    }
    while (iterations > 0) {
        if (iterations % 20000 == 0) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException ie) {
            }
        }
        iterations--;
    }

    if (db) {
        Statistics statistics = new Statistics();
        statistics.type = Type.CPU;
        statistics.parameter = iterations.toString();
        statistics.duration = Duration.between(start, Instant.now());
        statistics.description = desc;
        repository.save(statistics);
    }

    String msg = "Micronaut: CPU consumption is done with " + iterationsDone + " iterations in " + Duration.between(start, Instant.now()).getNano() + " nano-seconds.";
    if (db) {
        msg += " The result is persisted in the database.";
    }
    return msg;
}

@Get(uri = "/memory", produces = MediaType.TEXT_PLAIN)
public String memory(@QueryValue(value = "bites", defaultValue = "10") Integer bites,
                     @QueryValue(value = "db", defaultValue = "false") Boolean db,
                     @QueryValue(value = "desc", defaultValue = "") String desc) {
    LOGGER.log(INFO, "Micronaut: memory: {0} {1} with desc {2}", bites, db, desc);

    Instant start = Instant.now();
    if (bites == null) {
        bites = 1;
    }
    HashMap hunger = new HashMap<>();
    for (int i = 0; i < bites * 1024 * 1024; i += 8192) {
        byte[] bytes = new byte[8192];
        hunger.put(i, bytes);
        for (int j = 0; j < 8192; j++) {
            bytes[j] = '0';
        }
    }

    if (db) {
        Statistics statistics = new Statistics();
        statistics.type = Type.MEMORY;
        statistics.parameter = bites.toString();
        statistics.duration = Duration.between(start, Instant.now());
        statistics.description = desc;
        repository.save(statistics);
    }

    String msg = "Micronaut: Memory consumption is done with " + bites + " bites in " + Duration.between(start, Instant.now()).getNano() + " nano-seconds.";
    if (db) {
        msg += " The result is persisted in the database.";
    }
    return msg;
}

@Get(uri = "/stats", produces = MediaType.APPLICATION_JSON)
public List<Statistics> stats() {
    LOGGER.log(INFO, "Micronaut: retrieving statistics");
    List<Statistics> result = new ArrayList<Statistics>();
    for (Statistics stats : repository.findAll()) {
        result.add(stats);
    }
    return result;
}

package io.containerapps.javaruntime.workshop.micronaut;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.time.Duration;
import java.time.Instant;

@Entity
@Table(name = "Statistics_Micronaut")
public class Statistics {

    @GeneratedValue
    @Id
    private Long id;
    @Column(name = "done_at")
    public Instant doneAt = Instant.now();
    public Framework framework = Framework.MICRONAUT;
    public Type type;
    public String parameter;
    public Duration duration;
    public String description;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
}

enum Type {
    CPU, MEMORY
}

enum Framework {
    QUARKUS, MICRONAUT, SPRINGBOOT
}

package io.containerapps.javaruntime.workshop.micronaut;

import io.micronaut.data.annotation.Repository;
import io.micronaut.data.repository.CrudRepository;

@Repository
interface StatisticsRepository extends CrudRepository<Statistics, Long> {
}

mvn compile

micronaut:
  application:
    name: MicronautApp
  server:
    port: 8702
    thread-selection: IO
netty:
  default:
    allocator:
      max-order: 3
datasources:
  default:
    dialect: POSTGRES
    url: jdbc:postgresql://localhost:5432/postgres
    username: postgres
    password: password
    driverClassName: org.postgresql.Driver
jpa:
  default:
    entity-scan:
      packages: 'io.containerapps.javaruntime.workshop.micronaut'
    properties:
      hibernate:
        bytecode:
          provider: none
        hbm2ddl:
          auto: none

package io.containerapps.javaruntime.workshop.micronaut;

import io.micronaut.runtime.EmbeddedApplication;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.Assertions;

import jakarta.inject.Inject;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@MicronautTest
class MicronautAppTest {

    private PostgreSQLContainer postgreSQLContainer;

    @Inject
    EmbeddedApplication<?> application;

    @BeforeEach
    public void setUp() {
        postgreSQLContainer = new PostgreSQLContainer("postgres:14")
            .withDatabaseName("postgres")
            .withUsername("postgres")
            .withPassword("password");
    }

    @Test
    void testItWorks() {
        Assertions.assertTrue(application.isRunning());
    }

}

package io.containerapps.javaruntime.workshop.micronaut;

import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import io.restassured.specification.RequestSpecification;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Testcontainers;

import static io.restassured.RestAssured.given;
import static org.hamcrest.CoreMatchers.*;

@Testcontainers
@MicronautTest
class MicronautResourceTest {

    private static String basePath = "http://localhost:8802/micronaut";

    private PostgreSQLContainer postgreSQLContainer;

    @BeforeEach
    public void setUp() {
        postgreSQLContainer = new PostgreSQLContainer("postgres:14")
            .withDatabaseName("postgres")
            .withUsername("postgres")
            .withPassword("password");
    }
}

@Test
public void testHelloEndpoint(RequestSpecification spec) {
    spec
      .when().get(basePath)
      .then()
        .statusCode(200)
        .body(is("Micronaut: hello"));
}

@Test
public void testCpuWithDBAndDescEndpoint() {
    given().param("iterations", 1).param("db", true).param("desc", "Java17")
      .when().get(basePath + "/cpu")
      .then()
        .statusCode(200)
        .body(startsWith("Micronaut: CPU consumption is done with"))
        .body(not(containsString("Java17")))
        .body(endsWith("The result is persisted in the database."));
}

@Test
public void testMemoryWithDBAndDescEndpoint() {
    given().param("bites", 1).param("db", true).param("desc", "Java17")
      .when().get(basePath + "/memory")
      .then()
        .statusCode(200)
        .body(startsWith("Micronaut: Memory consumption is done with"))
        .body(not(containsString("Java17")))
        .body(endsWith("The result is persisted in the database."));
}

@Test
public void testStats() {
    given()
        .when().get(basePath + "/stats")
        .then()
        .statusCode(200);
}

mvn test

[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

docker compose -f postgres.yaml up

mvn mn:run

curl 'localhost:8702/micronaut'

curl 'localhost:8702/micronaut/cpu?iterations=10&db=true&desc=java17'

curl 'localhost:8702/micronaut/memory?bites=10&db=true&desc=java17'

curl 'localhost:8702/micronaut/cpu?iterations=50'
curl 'localhost:8702/micronaut/cpu?iterations=100'
curl 'localhost:8702/micronaut/cpu?iterations=100&db=true'

curl 'localhost:8702/micronaut/memory?bites=50'
curl 'localhost:8702/micronaut/memory?bites=100'
curl 'localhost:8702/micronaut/memory?bites=100&db=true'

curl 'localhost:8702/micronaut/stats'

# or if you have "jq" installed you can make it prettier with
# curl 'localhost:8702/micronaut/stats' | jq

package io.containerapps.javaruntime.workshop.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringbootApplication.class, args);
	}

}

package io.containerapps.javaruntime.workshop.springboot;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.lang.System.Logger;
import java.time.Duration;
import java.time.Instant;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import static java.lang.System.Logger.Level.INFO;
import static java.lang.invoke.MethodHandles.lookup;

@RestController
@RequestMapping("/springboot")
public class SpringbootResource {

    private static final Logger LOGGER = System.getLogger(lookup().lookupClass().getName());

    private final StatisticsRepository repository;

    public SpringbootResource(StatisticsRepository statisticsRepository) {
        this.repository = statisticsRepository;
    }
}

@GetMapping(produces = MediaType.TEXT_PLAIN_VALUE)
public String hello() {
    LOGGER.log(INFO, "Spring Boot: hello");
    return "Spring Boot: hello";
}

@GetMapping(path = "/cpu", produces = MediaType.TEXT_PLAIN_VALUE)
public String cpu(@RequestParam(value = "iterations", defaultValue = "10") Long iterations,
                  @RequestParam(value = "db", defaultValue = "false") Boolean db,
                  @RequestParam(value = "desc", required = false) String desc) {
    LOGGER.log(INFO, "Spring Boot: cpu: {0} {1} with desc {2}", iterations, db, desc);
    Long iterationsDone = iterations;

    Instant start = Instant.now();
    if (iterations == null) {
        iterations = 20000L;
    } else {
        iterations *= 20000;
    }
    while (iterations > 0) {
        if (iterations % 20000 == 0) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException ie) {
            }
        }
        iterations--;
    }

    if (db) {
        Statistics statistics = new Statistics();
        statistics.type = Type.CPU;
        statistics.parameter = iterations.toString();
        statistics.duration = Duration.between(start, Instant.now());
        statistics.description = desc;
        repository.save(statistics);
    }

    String msg = "Spring Boot: CPU consumption is done with " + iterationsDone + " iterations in " + Duration.between(start, Instant.now()).getNano() + " nano-seconds.";
    if (db) {
        msg += " The result is persisted in the database.";
    }
    return msg;
}

@GetMapping(path = "/memory", produces = MediaType.TEXT_PLAIN_VALUE)
public String memory(@RequestParam(value = "bites", defaultValue = "10") Integer bites,
                     @RequestParam(value = "db", defaultValue = "false") Boolean db,
                     @RequestParam(value = "desc", required = false) String desc) {
    LOGGER.log(INFO, "Spring Boot: memory: {0} {1} with desc {2}", bites, db, desc);

    Instant start = Instant.now();
    if (bites == null) {
        bites = 1;
    }
    HashMap hunger = new HashMap<>();
    for (int i = 0; i < bites * 1024 * 1024; i += 8192) {
        byte[] bytes = new byte[8192];
        hunger.put(i, bytes);
        for (int j = 0; j < 8192; j++) {
            bytes[j] = '0';
        }
    }

    if (db) {
        Statistics statistics = new Statistics();
        statistics.type = Type.MEMORY;
        statistics.parameter = bites.toString();
        statistics.duration = Duration.between(start, Instant.now());
        statistics.description = desc;
        repository.save(statistics);
    }

    String msg = "Spring Boot: Memory consumption is done with " + bites + " bites in " + Duration.between(start, Instant.now()).getNano() + " nano-seconds.";
    if (db) {
        msg += " The result is persisted in the database.";
    }
    return msg;
}

@GetMapping(path = "/stats", produces = MediaType.APPLICATION_JSON_VALUE)
public List<Statistics> stats() {
    LOGGER.log(INFO, "Spring Boot: retrieving statistics");
    List<Statistics> result = new ArrayList<Statistics>();
    for (Statistics stats : repository.findAll()) {
        result.add(stats);
    }
    return result;
}

package io.containerapps.javaruntime.workshop.springboot;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

import java.time.Duration;
import java.time.Instant;

@Entity
@Table(name = "Statistics_Springboot")
public class Statistics {

    @GeneratedValue
    @Id
    private Long id;
    @Column(name = "done_at")
    public Instant doneAt = Instant.now();
    public Framework framework = Framework.SPRINGBOOT;
    public Type type;
    public String parameter;
    public Duration duration;
    public String description;
}

enum Type {
    CPU, MEMORY
}

enum Framework {
    QUARKUS, MICRONAUT, SPRINGBOOT
}

package io.containerapps.javaruntime.workshop.springboot;

import org.springframework.data.repository.CrudRepository;

interface StatisticsRepository extends CrudRepository<Statistics, Long> {
}

mvn compile

server.port=8703
spring.datasource.url=jdbc:postgresql://localhost:5432/postgres
spring.datasource.username=postgres
spring.datasource.password=password

## Hibernate Properties
spring.jpa.open-in-view=false
#spring.jpa.show-sql=true

# Hibernate ddl auto (create, create-drop, validate, update)
spring.jpa.hibernate.ddl-auto=none

package io.containerapps.javaruntime.workshop.springboot;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT, properties = {
    "spring.datasource.url=jdbc:tc:postgresql:14-alpine://testcontainers/postgres",
    "spring.datasource.username=postgres",
    "spring.datasource.password=password"
})
class SpringbootApplicationTests {

	@Test
	void contextLoads() {
	}

}

package io.containerapps.javaruntime.workshop.springboot;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertEquals;

@SpringBootTest(webEnvironment = WebEnvironment.DEFINED_PORT, properties = {
    "server.port=8803",
    "spring.datasource.url=jdbc:tc:postgresql:14-alpine://testcontainers/postgres",
    "spring.datasource.username=postgres",
    "spring.datasource.password=password"
})
class SpringbootResourceTest {

    private static String basePath = "http://localhost:8803/springboot";

    @Autowired
    private TestRestTemplate restTemplate;
}

@Test
public void testHelloEndpoint() {
    ResponseEntity<String> response = this.restTemplate.
        getForEntity(basePath, String.class);

    assertEquals(response.getStatusCode(), HttpStatus.OK);
    assertThat(response.getBody()).contains("Spring Boot: hello");
}

@Test
public void testCpuWithDBAndDescEndpoint() {
    ResponseEntity<String> response = this.restTemplate.
        getForEntity(basePath + "/cpu?iterations=1&db=true&dec=Java17", String.class);

    assertEquals(response.getStatusCode(), HttpStatus.OK);
    assertThat(response.getBody())
        .startsWith("Spring Boot: CPU consumption is done with")
        .doesNotContain("Java17")
        .endsWith("The result is persisted in the database.");
}

@Test
public void testMemoryWithDBAndDescEndpoint() {
    ResponseEntity<String> response = this.restTemplate.
        getForEntity(basePath + "/memory?bites=1&db=true&desc=Java17", String.class);

    assertEquals(response.getStatusCode(), HttpStatus.OK);
    assertThat(response.getBody())
        .startsWith("Spring Boot: Memory consumption is done with")
        .doesNotContain("Java17")
        .endsWith("The result is persisted in the database.");
}

@Test
public void testStats() {
    ResponseEntity<String> response = this.restTemplate.
        getForEntity(basePath + "/stats", String.class);

    assertEquals(response.getStatusCode(), HttpStatus.OK);
}

mvn test

[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

docker compose -f postgres.yaml up

mvn spring-boot:run

curl 'localhost:8703/springboot'

curl 'localhost:8703/springboot/cpu?iterations=10&db=true&desc=java17'

curl 'localhost:8703/springboot/memory?bites=10&db=true&desc=java17'

curl 'localhost:8703/springboot/cpu?iterations=50'
curl 'localhost:8703/springboot/cpu?iterations=100'
curl 'localhost:8703/springboot/cpu?iterations=100&db=true'

curl 'localhost:8703/springboot/memory?bites=50'
curl 'localhost:8703/springboot/memory?bites=100'
curl 'localhost:8703/springboot/memory?bites=100&db=true'

curl 'localhost:8703/springboot/stats'

# or if you have "jq" installed you can make it prettier with
# curl 'localhost:8703/springboot/stats' | jq

az login

az account show

az config set extension.use_dynamic_install=yes_without_prompt
az provider register --namespace Microsoft.App
az provider register --namespace Microsoft.OperationalInsights
az provider register --namespace Microsoft.Insights

name: Build and deploy to Azure Container Apps

# Controls when the action will run.
# We want to run this workflow every time a commit is pushed to the 'main' branch
on:
  push:
    branches: [main]

# Only allow one workflow to run at a time
concurrency:
  group: deployment

env:
  # Replace with your registry URL
  REGISTRY_URL: crjavaruntimessinedied.azurecr.io
  PROJECT: java-runtimes
  RESOURCE_GROUP: rg-java-runtimes
  QUARKUS_APP: quarkus-app
  MICRONAUT_APP: micronaut-app
  SPRING_APP: springboot-app

# A workflow run is made up of one or more jobs.
# Unless you specify dependencies, jobs run in parallel by default.
jobs:

  # Define our "build" job, that will be the CI part of our pipeline
  build:
    # The type of runner that the job will run on.
    # Many runners are available, including Windows, macOS, and Linux.
    runs-on: ubuntu-latest

    # Steps represent a sequence of tasks (actions) that will be executed as
    # part of the job.
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Java
        uses: actions/setup-java@v3
        with:
          distribution: 'microsoft'
          java-version: '17'
          cache: 'maven'

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2

      - name: Log in to container registry
        uses: docker/login-action@v2
        with:
          registry: ${{ env.REGISTRY_URL }}
          username: ${{ secrets.REGISTRY_USERNAME }}
          password: ${{ secrets.REGISTRY_PASSWORD }}

az postgres flexible-server execute \
  --name "$POSTGRES_DB" \
  --admin-user "$POSTGRES_DB_ADMIN" \
  --admin-password "$POSTGRES_DB_PWD" \
  --database-name "$POSTGRES_DB_SCHEMA" \
  --querytext "select Duration, Parameter, Description from Statistics_Quarkus" \
  --output table

az postgres flexible-server execute \
  --name "$POSTGRES_DB" \
  --admin-user "$POSTGRES_DB_ADMIN" \
  --admin-password "$POSTGRES_DB_PWD" \
  --database-name "$POSTGRES_DB_SCHEMA" \
  --querytext "select Duration, Parameter, Description from Statistics_Micronaut" \
  --output table

az postgres flexible-server execute \
  --name "$POSTGRES_DB" \
  --admin-user "$POSTGRES_DB_ADMIN" \
  --admin-password "$POSTGRES_DB_PWD" \
  --database-name "$POSTGRES_DB_SCHEMA" \
  --querytext "select Duration, Parameter, Description from Statistics_Springboot" \
  --output table

mvn -Pnative package

%prod.quarkus.datasource.username=postgres
%prod.quarkus.datasource.password=password
%prod.quarkus.datasource.jdbc.url=jdbc:postgresql://localhost:5432/postgres

docker compose -f postgres.yaml up

./target/quarkus-app-1.0.0-SNAPSHOT-runner

curl 'localhost:8701/quarkus'

curl 'localhost:8701/quarkus/cpu?iterations=10&db=true&desc=native'

curl 'localhost:8701/quarkus/memory?bites=10&db=true&desc=native'

mvn package -Dpackaging=native-image

./target/micronaut-app

curl 'localhost:8702/micronaut'

curl 'localhost:8702/micronaut/cpu?iterations=10&db=true&desc=native'

curl 'localhost:8702/micronaut/memory?bites=10&db=true&desc=native'

mvn -Pnative native:compile

./target/springboot-app

curl 'localhost:8703/springboot'

curl 'localhost:8703/springboot/cpu?iterations=10&db=true&desc=native'

curl 'localhost:8703/springboot/memory?bites=10&db=true&desc=native'

az group delete --name "$RESOURCE_GROUP"