Building MyZubster with Nicola: Connecting Two Independent Systems Without Exposing a Local Computer
Can two developers collaborate through independent environments without exposing their local infrastructure to the public internet?
This is one of the questions we're exploring with MyZubster.
I'm working with Nicola (N4K48), a contributor who has been developing his own local MyZubster environment, including the Nicola Comics pilot. We're gradually connecting our work across Docker, knowledge graphs, verifiable evidence and decentralized technologies.
Rather than building everything at once, we're following an incremental approach: implement, test, document and verify.
1. Our latest experiment: MyZubster Node Bridge
We've developed a small Python-based communication bridge running inside Docker on a VPS.
The architecture is deliberately simple:
Nicola's computer → HTTPS → Nginx → Python Node Bridge
The bridge uses two separate authentication roles:
- A node token for retrieving requests and submitting results.
- An administrative token for creating requests and checking their status.
Nginx exposes only the endpoints needed by the remote node:
GET /node/nextPOST /node/result
Administrative endpoints remain inaccessible through the public reverse proxy.
The bridge listens locally on the VPS, and HTTPS is enabled using Let's Encrypt.
We've already verified the following:
- Docker container health checks.
- Local broker communication.
- Simulated request and response handling.
- HTTPS certificate installation.
- Authentication enforcement.
- Blocking of administrative endpoints.
- Public domain connectivity from the VPS.
Our next step is to connect Nicola's actual computer and validate the complete communication cycle.
An important distinction: our simulated tests were successful, but we haven't yet completed the end-to-end test between the two physical environments.
2. Beyond infrastructure: building verifiable knowledge
Our collaboration also extends to MyZubster's Knowledge Graph.
Nicola recently worked on improving how evidence is synchronized, identified and displayed.
Our MYZ-209 work included:
- Stable identifiers for evidence.
- Deduplication.
- Knowledge Card synchronization.
- Preserving historical Proof v2 attestations.
- Displaying Proof v3 as a separate, identifiable attestation.
The changes were merged, and Nicola subsequently confirmed the expected behavior in production.
We're also documenting our shared learning activities involving Docker, Ethereum Sepolia, Base Sepolia, MetaMask and Zorgax.
An important principle guides this work:
Documented technical activity is evidence of an activity, not automatic certification of expertise.
We distinguish independently verifiable technical results from personal learning experiences and activities that still require confirmation.
3. Nicola Comics: a practical integration scenario
Nicola's local comics catalog gives us a concrete application for testing the bridge.
Our initial goal is to request catalog information remotely while keeping the underlying local environment under Nicola's control.
We're starting with simple operations such as retrieving the gallery and requesting comic details.
Future experiments may explore how comics, knowledge records and blockchain-based attestations could interact.
However, a technical demonstration is not equivalent to publishing an NFT or establishing ownership rights. Those would require separate verification and explicit authorization.
4. What we're learning
This project is raising several interesting engineering questions.
How much functionality should a small communication bridge expose?
How can we establish trust between independent environments without opening local services to the internet?
How do we document a successful experiment without overstating what it proves?
And how can contributors retain control over their environments while participating in a shared ecosystem?
Our approach is to keep the integration small, authentication explicit, administrative access restricted and experimental results clearly documented.
The next milestone is a real end-to-end test from Nicola's computer.
I'd be interested to hear how other developers approach secure communication between independently managed Docker environments.
Would you use a lightweight HTTPS polling bridge, a message broker or another architecture?
MyZubster #Docker #OpenSource #Cybersecurity #Python #KnowledgeGraph #Web3 #SoftwareDevelopment