ACME | repository contains open-source C code

If I understand, here is one way to do it:

• Read in the two tables
• split the Export table state abbreviations into ROWS
• Join with the StateName Table
• Group by Name and Company
• Extract a delimited list of the state names from each subtable
• Expand that list

Please read the code comments and explore the Applied Steps to better understand what is going on

What you configured is the Connection source enforcement which makes sure that a Hono device (identified via the AMQP header device_id) may only updates the twin with the same "thing id" in Ditto.

That enforcement fails as your thingId you set in the Ditto Protocol JSON is my-tenant:org.acme:my-device-1 - the topic's first segment is the namespace, the second segment the name - combined those 2 segments become the "thing ID", see also: Protocol topic specification.

So you probably want to send the following message instead:

Dot Points:

• include $request_uri in your proxy pass
• provide a resolver in your proxy location block
• declare an entry for your container in Docker's network stack
• use all lower case in your service name

Below is the configuration file I use to reverse proxy through to a Ubiquiti Unifi container. All my certbot is handled off site so I need not consider that here. If you compare our location blocks, the issue will likely become immediately apparent, but I'll explain for clarity's sake.

What you need to look at is your Proxy Pass directive. This is of course where the magic proxying happens. I notice that you have not been including the $request_uri, so any request nginx receives for bound.example.com/testpage1, it will send a request to the upstream apache server for bound.example.com. Of course if you need to include a port, as I have done here 8443, this is the place to do it also.

If you include this variable, it should resolve your problem.

The following does not answer your question, but I thought I would include it also just as some helpful information.

Also, I just want to note that I have included a resolver. The IP address 127.0.0.11 points to Docker's internal DNS resolver. Chances are you won't need to include this, however I did so myself to ensure I didn't get odd problems. Lastly, I'd just like to recommend that you look into upgrading your SSL settings, to ensure that you are safe from attacks from weaker SSL / TLS versions.

I expect that adding the variable $request_uri to your proxy pass directive is all that is required to get your site working.

First you should registrer your other proto to the schema registry.

Create a json (named other-proto.json) file with following syntax:

You need to use TLS for your local setup. The host you need a certificate for is local.example.com. There is no way to obtain a certificate from Letsencrypt for this name, because you're not controlling the example.com domain. One of the ways Letsencrypt creates a certificate is a challenge - you prove that you own the domain by creating a TXT DNS record. If you own a domain you can do that, but your case is different, because you only need this for local development.

However, you can just use openssl to generate a self signed certificate for whichever domain name you want. This is a good reference on how to do this. You can use the local.example.com domain name for the generated certificate. If you're successful, you'll end up with the certificate and it's private key. Note where you save those files, as you'll need them. Keep in mind that the certificate is self-signed, so your browser will give you a warning, unless you add this certificate to the trust store of your operating system.

The next step in your case is to make Traefik use those self signed certificates when serving content from your application. I think this answer has a good example of that.

After having this, you'll only need to edit your hosts file and redirect your localhost:8080 (the port on which your Traefik serves your application) to local.example.com.

Also, Traefik is not the only solution for your case. You can also achieve the same using Nginx, for example. Choose which one satisfies your use case. My suggestion would be to use the one that's easiest to configure, because it's for local development. Here's the first result I got when searching for a nginx docker-compose self-signed certificate.

UPDATE
Here's a quick example of what I'm describing above.
First generate the certificate:

Let's Encrypt blocks Amazon AWS domains because the domain names are transient and are subject to change.

https://community.letsencrypt.org/t/policy-forbids-issuing-for-name-on-amazon-ec2-domain/12692/4

Ok, the trick is to simply not provide an explicit version for spring-kafka (in my case in the build.gradle.kts), but let the Spring dependency management (id("io.spring.dependency-management") version "1.0.11.RELEASE") choose the appropriate one.

2.7.7 is the version that is then currently chosen automatically (with Spring Boot version 2.5.5).

The used (spring standard) "factory" implements FactoryBean as InitializingBean ...

I have not tested this, but I asume something like this should do the trick: