Infrastructure learning project
A learning project that rebuilds network and infrastructure components with standard libraries. The public main branch currently contains a Python HTTP client, a minimal HTTP server, and a local Go DNS MVP.
In progress
The public main branch contains three small network components and their tests. They are intentionally isolated and readable; the full service chain is not integrated yet.
The client in http-server/client.py accepts [http://]host[:port][/path], defaults to port 80, builds an HTTP/1.0 GET request, and reads the status line, headers, and body from the socket. Unsupported transfer and content encodings are rejected explicitly.
http-server/server.py sequentially binds to 0.0.0.0:8088, reads one request segment, and returns a CRLF-framed HTTP/1.1 response with Content-Length, Connection: close, and HELLO WORLD!.
dns-server/server.go answers UDP queries on 127.0.0.1:8053. An A query for app.local returns 127.0.0.1; unknown names receive NXDOMAIN, while unsupported or malformed queries stay deliberately limited.
http-server/tests/ covers URL parsing, client-server integration, refused connections, HTTPS rejection, and the server smoke test. dns-server/server_test.go covers the known record, NXDOMAIN, unsupported types, and malformed packets.
The README files document how to run and test each component. ADRs record the Python unittest choice, the Go choice, and the DNS MVP test structure.
The sequence remains an architecture roadmap, not a proven end-to-end deployment. The client, DNS MVP, and one HTTP server exist separately; load balancing and the Redis connection are not implemented yet.
The Python client is the first concrete component and sends HTTP/1.0 GET requests over a socket.
The Go DNS MVP answers local A queries for app.local on 127.0.0.1:8053.
Not implemented yet; this component is intended to address multiple HTTP servers later.
A minimal Python server answers on 0.0.0.0:8088; multiple servers and the distribution layer remain planned.
Not implemented yet; a Redis clone is intended to add simple state and data flows later.
The current state grows from isolated, tested network components toward a connected learning environment. Each new stage remains measurable through repository code and tests.
Python sockets make URL handling, requests, responses, and simple connection lifecycles tangible.
A small Go UDP service models bounded A-record resolution with a fixed local record.
Standard toolchains, smoke and behavior tests, and ADRs keep the learning steps reproducible.
Study routing, forwarding, and request distribution as separate responsibilities.
Rebuild state storage and process isolation as additional foundations.
Add heartbeat, registration, producer, consumer, and persistent object flows.
Model observation, resource assignment, and signed TLS communication as later topics.
The public main branch contains a Python HTTP client, a minimal Python HTTP server, and a Go DNS MVP. All three components have matching tests; the end-to-end chain has not been built yet.
This page therefore separates the evidenced repository state from the README roadmap. Reverse proxy, load balancer, Redis clone, container runtime, and the other extensions remain targets. The public repository code, tests, and documentation remain authoritative.
