DEV Community: WN

Use Chatgpt to create a webhook microservice

WN — Sat, 29 Apr 2023 04:28:16 +0000

Introduction

ChatGPT is a large language model that has been trained on a massive dataset of human language, allowing it to understand and generate natural language. One of the most exciting applications of ChatGPT is in programming, where it can automate the process of generating code. In this article, we will explore how good ChatGPT is at writing code and the potential benefits and limitations of using ChatGPT to generate programming code.

Let's get started

Let's try with a really long and complex reqirement prompt.

Please act as a senior backend developer and write a webhook microservice in Java using the Spring Boot Framework. Please do not skip any implementations inside method. The program should be easy to maintain with high readability and expandability. No TODO should be written in the code.

The microservice will be a webhook service that will be managed by Gradle. The API endpoints will follow the design standards of a REST API. The microservice will have two entities: Session and History. The Session entity will represent a webhook session, which will have a unique ID in UUID format. The History entity will represent a request made to this webhook session,including the request time, URL, and HTTP method. The History entity will have a many-to-one relationship with the Session entity.

The microservice will expose the following endpoints:

A "webhook" endpoint in POST method to create a new webhook session. This endpoint will generate a new UUID.
A "webhook/{uuid}/config" endpoint to allow the user to configure what response should be returned in the "webhook" endpoint based on the regular expression string. This endpoint will accept a regular expression string and a jsonNode. A session can have multiple pairs sof regular expression and response.
A "webhook/{uuid}" endpoint to receive HTTP requests, save them into MongoDB, and return a response matched the first regular expression based on the request URL in the "configure" endpoint in JSON. This endpoint will accept any kind of HTTP method. If the user does not configure the response, the default JSON response will be "{'status': 'success'}".
A "webhook/{uuid}/history" endpoint to allow the user to search all webhook records.

Use H2 Database.

A schueduler should be set to housekeep the data periodically. A webhook session should be kept for one week only, and all child histories under the session should be removed as well.

Please follow the programming style of Domain Driven Design and Test Driven Design. Using Lombok and annotation is highly encouraged.

Result

Sure, here's an implementation of the webhook microservice in Java using the Spring Boot framework:

Session Entity:

@Entity
@Data
@NoArgsConstructor
public class Session {

    @Id
    private UUID id;
    @OneToMany(mappedBy = "session", cascade = CascadeType.ALL)
    private List<History> histories;

    public Session(UUID id) {
        this.id = id;
    }
}

History Entity:

@Entity
@Data
@NoArgsConstructor
public class History {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String url;
    private String method;
    private LocalDateTime requestTime;
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "session_id")
    private Session session;

    public History(String url, String method, LocalDateTime requestTime, Session session) {
        this.url = url;
        this.method = method;
        this.requestTime = requestTime;
        this.session = session;
    }
}

SessionRepository:

@Repository
public interface SessionRepository extends JpaRepository<Session, UUID> {

}

HistoryRepository:

@Repository
public interface HistoryRepository extends JpaRepository<History, Long> {

    List<History> findBySessionId(UUID sessionId);
}

WebhookController:

@RestController
@RequestMapping("/webhook")
public class WebhookController {

    @Autowired
    private SessionRepository sessionRepository;
    @Autowired
    private HistoryRepository historyRepository;
    @Autowired
    private Scheduler scheduler;

    @PostMapping
    public ResponseEntity<UUID> createSession() {
        UUID sessionId = UUID.randomUUID();
        Session session = new Session(sessionId);
        sessionRepository.save(session);
        scheduler.scheduleSessionDeletion(sessionId);
        return ResponseEntity.ok(sessionId);
    }

    @PostMapping("/{uuid}/config")
    public ResponseEntity<Void> configureSession(@PathVariable("uuid") UUID sessionId,
                                                  @RequestParam("regex") String regex,
                                                  @RequestBody JsonNode response) {
        Optional<Session> optionalSession = sessionRepository.findById(sessionId);
        if (optionalSession.isPresent()) {
            Session session = optionalSession.get();
            session.addConfiguration(regex, response);
            sessionRepository.save(session);
            return ResponseEntity.ok().build();
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @RequestMapping(value = "/{uuid}", method = {RequestMethod.GET, RequestMethod.POST})
    public ResponseEntity<JsonNode> handleRequest(@PathVariable("uuid") UUID sessionId,
                                                   @RequestBody(required = false) String requestBody,
                                                   HttpServletRequest request) {
        Optional<Session> optionalSession = sessionRepository.findById(sessionId);
        if (optionalSession.isPresent()) {
            Session session = optionalSession.get();
            JsonNode response = session.getResponse(request.getRequestURI());
            History history = new History(request.getRequestURI(), request.getMethod(),
                    LocalDateTime.now(), session);
            historyRepository.save(history);
            return ResponseEntity.ok(response);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    @GetMapping("/{uuid}/history")
    public ResponseEntity<List<History>> getSessionHistory(@PathVariable("uuid") UUID sessionId) {
        List<History> histories = historyRepository.findBySessionId(sessionId);
        return ResponseEntity.ok(histories);
    }
}

SessionService:

@Service
public class SessionService {

    @Autowired
    private SessionRepository sessionRepository;

    public Session createSession() {
        UUID sessionId = UUID.randomUUID();
        Session session = new Session(sessionId);
        sessionRepository.save(session);
        return session;
    }

    public Optional<Session> getSession(UUID sessionId) {
        return sessionRepository.findById(sessionId);
    }

    public void configureSession(Session session, String regex, JsonNode response) {
        session.addConfiguration(regex, response);
        sessionRepository.save(session);
    }

    public JsonNode handleRequest(Session session, String uri) {
        return session.getResponse(uri);
    }
}

SessionScheduler:

@Component
public class SessionScheduler {

    @Autowired
    private SessionRepository sessionRepository;
    @Autowired
    private HistoryRepository historyRepository;

    @Scheduled(cron = "0 0 0 * * *")
    public void deleteExpiredSessions() {
        LocalDateTime expirationTime = LocalDateTime.now().minusWeeks(1);
        List<Session> expiredSessions = sessionRepository.findByCreatedBefore(expirationTime);
        for (Session session : expiredSessions) {
            historyRepository.deleteBySessionId(session.getId());
            sessionRepository.delete(session);
        }
    }
}

I hope this implementation meets your requirements. Let me know if you have any questions or need further assistance.

Reviewing the Generated Code

I found that the generated code is syntactically correct, but some methods are missing in the code. That's why it's important to review the generated code carefully and thoroughly, as it's very possible that the code may contain errors, especailly asking ChatGpt to write the entire program.

Debugging

Error message is prompted at start up: "Caused by: org.hibernate.type.descriptor.java.spi.JdbcTypeRecommendationException: Could not determine recommended JdbcType for com.fasterxml.jackson.databind.JsonNode", so I ask ChatGpt to debug. ChatGpt succesfully points out that the JsonNode field in Class "Configuration" cannot be determined.

So I request ChatGpt to fix the missing AttributeConverter for JsonNode, and the response is great.

@Converter
public class JsonNodeConverter implements AttributeConverter<JsonNode, String> {

    private static final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public String convertToDatabaseColumn(JsonNode jsonNode) {
        try {
            return objectMapper.writeValueAsString(jsonNode);
        } catch (JsonProcessingException e) {
            throw new IllegalArgumentException("Failed to convert JSON node to string", e);
        }
    }

    @Override
    public JsonNode convertToEntityAttribute(String json) {
        try {
            return objectMapper.readTree(json);
        } catch (IOException e) {
            throw new IllegalArgumentException("Failed to convert string to JSON node", e);
        }
    }
}

It seems that a shorter, well-defined and specific requirement prompt may be more effective in generating accurate code. Conversely, a longer requirement prompt is more challenging for ChatGPT to fully understand and may result in less accurate or less efficient code.

Final thoughts

I do believe that ChatGPT's coding capabilities are constantly evolving through ongoing training and optimization. While at present, ChatGPT's coding capabilities may be limited to simpler tasks and it may struggle with more complex programming tasks.

Good at:

Generating code snippets for specific tasks or functions
Providing explanations for programming concepts or terms
Identifying common syntax errors or bugs in simple code

Bad at:

Debugging complex programs with multiple layers of logic
Writing entire programs from scratch

ChatGPT can be a helpful tool for programmers, but it cannot fully replace human programmers. Instead, it can be used as a complementary tool for generating code, answering questions, and providing support for programming tasks.

Monitoring Your Spring Boot Application with Custom Metrics and Prometheus

WN — Thu, 13 Apr 2023 13:21:25 +0000

1. Background

In a microservice architecture, applications are composed of multiple independent services that work together to provide a larger functionality. While this approach offers benefits such as scalability and flexibility, it also introduces challenges in terms of monitoring and managing the application.

Integrating Prometheus with your microservices on Kubernetes can help address some of these challenges by providing the ability to monitor, alert, and visualize metrics across multiple services. This can help you identify and troubleshoot issues that span multiple services, which can be difficult in a distributed system.

2. Objective

To expose metrics to integrate Prometheus by Spring Boot Actuator
To Define custom metrics with Micrometer

We will run a demo Spring Boot application on Kubernetes with Istio.

3. Enabling Spring Boot Actuator Endpoints

Spring Boot Actuator is a great tool when deploying a Spring Boot application on Kubernetes as it provides built-in support for health checks, metrics, tracing, and security, making it a lot easier to operate and maintain the application.

Add Spring Actuator Dependencies to project



implementation 'org.springframework.boot:spring-boot-starter-actuator'

Just add following properties to your application.yml file to expose an endpoint at /actuator/prometheus to present a Prometheus scrape with the appropriate format.



management:
  endpoints:
    enabled-by-default: true
    web:
      exposure:
        include: '*'
  endpoint:
    health:
      show-details: always

Try to access the prometheus metrics endpoint (http://localhost:8080/actuator/prometheus)

Output



# HELP executor_active_threads The approximate number of threads that are actively executing tasks
# TYPE executor_active_threads gauge
executor_active_threads{name="applicationTaskExecutor",} 0.0
# HELP jvm_memory_usage_after_gc_percent The percentage of long-lived heap pool used after the last GC event, in the range [0..1]
# TYPE jvm_memory_usage_after_gc_percent gauge
jvm_memory_usage_after_gc_percent{area="heap",pool="long-lived",} 0.0034471343796665006
# HELP jvm_classes_loaded_classes The number of classes that are currently loaded in the Java virtual machine
# TYPE jvm_classes_loaded_classes gauge
jvm_classes_loaded_classes 7787.0
# HELP jvm_gc_pause_seconds Time spent in GC pause
# TYPE jvm_gc_pause_seconds summary
jvm_gc_pause_seconds_count{action="end of minor GC",cause="G1 Evacuation Pause",} 1.0
jvm_gc_pause_seconds_sum{action="end of minor GC",cause="G1 Evacuation Pause",} 0.101
# HELP jvm_gc_pause_seconds_max Time spent in GC pause
# TYPE jvm_gc_pause_seconds_max gauge
jvm_gc_pause_seconds_max{action="end of minor GC",cause="G1 Evacuation Pause",} 0.0
# HELP disk_total_bytes Total space for path
# TYPE disk_total_bytes gauge
...

4. Creating Your Custom Prometheus Metric

Add Micrometer Prometheus Dependencies to project



runtimeOnly 'io.micrometer:micrometer-registry-prometheus'

There are 4 core metric types in Prometheus. In this article, we focus on "Counter" and "Gauge". A Counter is used to count the number of occurrences of an event, here is an example of how to define a Counter.



@RestController
@RequestMapping("/api")
public class NewsController {

    private Counter counter;

    public NewsController(MeterRegistry registry) {
        // counter
        this.counter = Counter.builder("news_fetch_request_total").
                tag("version", "v1").
                description("News Fetch Count").
                register(registry);
    }

    @GetMapping("/news")
    public List<News> getNews() {
        counter.increment();
        return List.of(new News("Good News!"), new News("Bad News!"));
    }

}

We define a Counter named "news_fetch_request_total" and register it with the MeterRegistry. We also define an api endpoint getNews() that increments the counter each time it is called.

Try to access http://localhost:8080/api/news, it should return the following response.



[{"title":"Good News!"},{"title":"Bad News!"}]

Try to access the prometheus metrics endpoint again and search "news_fetch_request_total", and found that the value is 1.0 now.

And a Gauge is used to measure the value of a particular variable. We define a Gauge named "temperature" and register it with the MeterRegistry as well.



        Gauge.builder("temperature", () -> {
                    double min = 10, max = 30;
                    return min + new Random().nextDouble() * (max - min);
                }).
                tag("version", "v1").
                description("Temperature Record").
                register(registry);

5. Building and deploying a Docker image to a Kubernetes cluster

Create a Dockerfile to dockerize the Gradle project.



FROM openjdk:17-alpine3.14
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Run the following command to build and tag the Docker image.



docker build --build-arg JAR_FILE=build/libs/*.jar -t myorg/myapp .

Add the following annotations to deployment file to tell prometheus where to scrape metrics from the service.



annotations:
  prometheus.io/scrape: "true"
  prometheus.io/port: "8080"
  prometheus.io/path: "/actuator/prometheus"

Let's deploy it on Kubernetes cluster.



apiVersion: apps/v1
kind: Deployment
metadata:
  name: myapp-v1
  labels:
    app: myapp
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
      version: v1
  template:
    metadata:
      labels:
        app: myapp
        version: v1
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: "/actuator/prometheus"    
    spec:
      containers:
      - name: details
        image: docker.io/myorg/myapp
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080
        securityContext:
          runAsUser: 1000

6. Result

If you are working with Istio, you can use the istioctl command to forward the port, enabling the access on localhost.



istioctl dashboard prometheus

Custom metric "temperature" is found, yeah!

With the help of the Micrometer Prometheus and the Spring Boot Actuator, implementing custom metrics in your application is really straightforward. Hope this tutorial has been helpful in getting you started with creating custom Prometheus metrics in your Spring Boot application!

Getting Started with Docker, Kubernetes, and Istio on Windows

WN — Mon, 10 Apr 2023 14:19:19 +0000

Objective

To provide a comprehensive guide for beginners on how to Set up a local development environment using Docker, Kubernetes, and Istio. This article will cover the necessary steps to install and familiarize oneself with these technologies.

1. Installing Docker on Windows

Docker is a containerization platform used to build, ship, and run applications.

Go to the Docker website (https://www.docker.com/products/docker-desktop) and click on the "Download for Windows" button.
Once the download is complete, double-click the downloaded file to start the installation process.

Follow the on-screen instructions to install Docker Desktop on your Windows machine.

During the installation process, you may be prompted to enable Hyper-V and Containers features on your system. Follow the prompts to enable these features.

Once the installation is complete, Docker Desktop should launch automatically.

2. Enabling Kubernetes in Docker Desktop

Open Docker Desktop and click on the settings icon (gear icon) in the top-right corner of the window.

Click on the "Kubernetes" tab in the settings window.

Check "Enable Kubernetes" and "Show system containers" to enable the Kubernetes feature in Docker Desktop.

After Kubernetes is enabled, you can use the "kubectl" command-line tool to manage your Kubernetes clusters.

3. Installing Istio on Windows

Go to the Istio release page (https://github.com/istio/istio/releases) to download the installation file for window

<!-- The installation directory contains:



/samples - Sample applications, will be used in this tutorial
/bin - The istioctl client binary

Add istioctl to Path Environment Variable
For example, if the package is istio-1.17.2, then add \istio-1.17.2\bin Directory to Path Environment Variable

Run the following command to check if Istioctl is in the system PATH or not.



istioctl version

Output



client version: 1.17.2
control plane version: 1.17.2
data plane version: 1.17.2 (8 proxies)

Run the following command to install Istio.



$ istioctl install --set profile=demo

The "demo" profile is intended for evaluating a broad set of Istio features. For development purposes, it is a good option to start with.

4. Enable Kiali (Optional)

Kiali is a web-based dashboard that provides an overview of the microservices within an Istio service mesh. It allows you to view the topology of your microservices, see the traffic flow between them, and monitor the health of the services.

Istio provides a basic sample installation to quickly get Kiali up and running:



$ kubectl apply -f /samples/addons/kiali.yaml

This will deploy Kiali into your cluster. This is intended for demonstration only, and is not tuned for performance or security.

Once the installation is complete, run the following command to open Kiali web UI:



istioctl dashboard kiali

Open a web browser and navigate to the Kiali dashboard by entering the following URL: http://localhost:20001/kiali.

Reference: https://istio.io/latest/docs/ops/integrations/kiali/#installation

5. Creating a sample application

The default Istio installation uses automatic sidecar injection. Label the namespace that will host the application with istio-injection=enabled:



kubectl label namespace default istio-injection=enabled

Deploy the sample "bookinfo" project using the kubectl command:



kubectl apply -f /samples/bookinfo/platform/kube/bookinfo.yaml

Confirm all services and pods are correctly defined and running:



kubectl get pods

Output



NAME                             READY   STATUS    RESTARTS        AGE
details-v1-5ffd6b64f7-czr7w      2/2     Running   2 (6h40m ago)   10h
productpage-v1-979d4d9fc-lc59r   2/2     Running   2 (6h40m ago)   10h
ratings-v1-5f9699cfdf-ppf74      2/2     Running   2 (6h40m ago)   10h
reviews-v1-569db879f5-cj2xr      2/2     Running   2 (6h40m ago)   10h
reviews-v2-65c4dc6fdc-kjmnm      2/2     Running   2 (6h40m ago)   10h
reviews-v3-c9c4fb987-2hg5x       2/2     Running   2 (6h40m ago)   10h

If you previously installed Kiali, you can also click on the "Workloads" tab in the Kiali dashboard to see a list of all the workloads, including Pods, and their status.

To confirm that the Bookinfo application is running, send a request to it by a curl command from some pod, for example from ratings:



kubectl exec "$(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}')" -c ratings -- curl -sS productpage:9080/productpage | findstr /r "<title>.*</title>"

Output



    <title>Simple Bookstore App</title>

6. Using a Gateway to Expose Your App

Now that the Bookinfo services are up and running, you need to make the application accessible from outside of your Kubernetes cluster, e.g., from a browser.

Run the following command to apply a gateway used for this purpose.



kubectl apply -f /samples/bookinfo/networking/bookinfo-gateway.yaml

Run the following command to get the external IP address of the Istio ingress gateway:



kubectl get svc istio-ingressgateway -n istio-system

Note the "EXTERNAL-IP" value for the "istio-ingressgateway" service. This is the IP address that you will use to access the Bookinfo application externally.

For example, if the external IP address is 192.168.99.100, you would enter the following URL: http://192.168.99.100/productpage

Visit the Istio documentation website (https://istio.io/latest/docs/) to learn more about Istio's powerful features and best practices. Happy hacking!