Request on Micha Kops' Tech Notes

Single Class Java HTTP Client with Proxy and SSL/TLS Keystore Settings

Tue, 02 Aug 2022 00:00:00 +0200

Sometimes this is useful for the diagnosis of configuration and network problems of ones Java application.

This is our single-class HTTP client example without the need for external dependencies:

HttpTest.java

import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ProxySelector;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpRequest.BodyPublishers;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodyHandlers;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.security.cert.CertificateException;
import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class HttpTest {
    public static void main(String[] args)
        throws URISyntaxException, NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException, IOException, CertificateException {
        String bodyPayload = """
            ourpayload, json, xml, ...
            """;

        String keyStorePath = "/opt/keystore.jks";
        String keyStorePassword = "ABCDEFG";

        String proxyHost = "ourproxy.proxy";
        String uriString = "https://some-service/api";
        int proxyPort = 8080;
        int timeoutInSeconds = 60;

        KeyStore keyStore = KeyStore.getInstance("JKS");
        keyStore.load(new FileInputStream(keyStorePath), keyStorePassword.toCharArray());

        KeyManagerFactory keyManagerFactory = KeyManagerFactory.getInstance("PKIX");
        keyManagerFactory.init(keyStore, null);

        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance("PKIX"); // using same keystore for both
        trustManagerFactory.init(keyStore);

        SSLContext sslContext = SSLContext.getInstance("TLS");
        sslContext.init(keyManagerFactory.getKeyManagers(), trustManagerFactory.getTrustManagers(), null);

        HttpClient client = HttpClient.newBuilder()
                                      .proxy(
                                          ProxySelector.of(new InetSocketAddress(proxyHost, proxyPort)))
                                      .sslContext(sslContext)
                                      .build();
        URI uri = new URI(uriString);
        HttpRequest request = HttpRequest.newBuilder(uri)
                                         .POST(BodyPublishers.ofString(bodyPayload))
                                         .timeout(Duration.of(timeoutInSeconds, ChronoUnit.SECONDS))
                                         .build();
        System.out.printf("Sending POST request to %s, timeout: %ds%n", uri, timeoutInSeconds);
        try {
            HttpResponse response = client.send(request, BodyHandlers.ofString());
            System.out.println("Response received...");
            System.out.printf("\tResponse-Status: %d%n", response.statusCode());
            System.out.printf("\tResponse-Body: %s%n", response.body());
            System.out.println("-------------------------------------%n");

        } catch (IOException e) {
            System.err.printf("IOException caught: %s%n", e.getMessage());
            e.printStackTrace(System.err);
        } catch (InterruptedException e) {
            System.err.printf("IOException caught: %s%n", e.getMessage());
            e.printStackTrace(System.err);
        }
    }
}

Implementing Reactive Client-Server Communication over TCP or Websockets with RSocket and Java

Sun, 25 Nov 2018 00:00:00 +0100

Reactive design or reactive architecture has an impact on how modern software systems are implemented. RSocket is a project that aims to adapt the benefits of the patterns described in the Reactive Manifesto and resulting tools like Reactive Streams or Reactive Extensions to a formal new communication protocol.

RSocket works with TCP, WebSockets and Aeron transport layers and offers additional features like session resumption.

In the following tutorial I’m going to demonstrate how to implement simple client-server communication over TCP and Websockets for different interaction models like request-response, request-stream, fire-and-forget and event subscription.

AWS Snippets

Thu, 01 Mar 2018 00:00:00 +0100

AWS Command Line Interface

Installation

$ curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64-2.0.30.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install

AWS Documentation

RDS

Export Database Configuration

Export instance configuration

aws rds describe-db-instances --db-instance-identifier arn:aws:rds:eu-central-1:123456789:db:hascode-prd-db --no-paginate

Export parameter group configuration

aws rds describe-db-parameters --db-parameter-group-name PARAM_GROUP_NAME >> param_group_conf.json

Export option group configuration

aws rds describe-option-groups --option-group-name OPT_GROUP_NAME >> option_group_conf.json

Generate Signed URLs with Linux Tools

e.g. for accessing a website behind a CloudFront distribution using a canned policy.

Write the policy file