mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
Every page now loads /webmcp.js, scripts/webmcp.ts with its types stripped (npm run webmcp). Where the browser has document.modelContext it registers two read-only tools: search_skills over the published skills index, and get_skill, which returns a skill's markdown checked against the index digest. The markdown alternate link moves from build.py to site.py, so CI holds every page to it. The API catalog gains the site itself (llms.txt and the skills index) and hanzo.ai/agents; the live discovery check now fetches every catalog link. tests/site.mjs drives the tools through a recording modelContext, and checks a browser without one loads clean.
464 lines
24 KiB
HTML
464 lines
24 KiB
HTML
<!doctype html>
|
|
<html lang="en"><head>
|
|
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
|
<title>hanzo-coursework-fullstack-go-cloud</title>
|
|
<meta name="color-scheme" content="dark">
|
|
<style>
|
|
/* Committed to one visual world: a dark instrument panel. No light variant —
|
|
the dot field and the hairline rules only read on black, and a naive
|
|
inversion would wash both out. Every colour is painted explicitly so the page
|
|
never borrows a host background. */
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
|
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
|
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
|
|
|
:root{
|
|
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
|
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
|
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
|
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
|
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
|
--mono:var(--font-zen-mono);
|
|
--sans:var(--font-zen-sans);
|
|
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
|
--r:999px; --r-soft:14px;
|
|
}
|
|
*{box-sizing:border-box}
|
|
html{-webkit-text-size-adjust:100%}
|
|
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
|
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
|
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
|
|
|
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
|
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
|
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
|
would cut off the copy-prompt menu. */
|
|
.hero{position:relative;border-bottom:1px solid var(--line)}
|
|
.hero::before{content:"";position:absolute;inset:0;
|
|
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
|
background-size:7px 7px;
|
|
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
|
pointer-events:none}
|
|
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
|
|
|
nav{border-bottom:1px solid var(--line)}
|
|
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
|
justify-content:space-between;align-items:center;gap:1rem}
|
|
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
|
display:inline-flex;align-items:center;gap:.6rem}
|
|
.brand i{font-style:normal;color:var(--faint)}
|
|
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
|
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
|
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
|
nav a.up:hover{color:var(--ink)}
|
|
|
|
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
|
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
|
h1 em{font-style:normal;color:var(--faint)}
|
|
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
|
|
|
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
|
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
|
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
|
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
|
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
|
line-height:1.2;font-weight:400}
|
|
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
|
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
|
.btn.solid:hover{background:#d8d8d4}
|
|
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
|
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
|
|
|
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
|
.copy{position:relative;display:inline-flex}
|
|
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
|
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
|
padding:.4rem;display:flex;flex-direction:column;
|
|
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
|
.menu[hidden]{display:none}
|
|
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
|
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
|
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
|
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
|
white-space:nowrap}
|
|
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
|
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
|
.mi:hover .mark{color:var(--ink)}
|
|
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
|
letter-spacing:.1em;text-transform:uppercase}
|
|
|
|
/* Works-with bar: one scrolling row, name and mark per agent. */
|
|
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
|
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
|
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
|
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
|
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
|
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
|
display:flex;align-items:center}
|
|
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
|
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
|
-webkit-overflow-scrolling:touch;
|
|
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
|
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
|
.bar::-webkit-scrollbar{display:none}
|
|
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
|
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
|
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
|
text-decoration:none;background:var(--ground)}
|
|
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
|
.agent .mark{width:.95rem;height:.95rem}
|
|
|
|
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
|
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
|
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
|
p{margin:0 0 1rem;max-width:70ch}
|
|
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
|
li{margin:.22rem 0}
|
|
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
|
text-decoration-color:var(--line-hi)}
|
|
a:hover{text-decoration-color:var(--ink)}
|
|
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
|
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
|
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
|
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
|
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
|
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
|
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
|
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
|
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
|
display:block;overflow-x:auto}
|
|
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
|
|
|
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
|
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
|
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
|
white-space:pre;line-height:1.9}
|
|
.curl b{color:var(--ink);font-weight:400}
|
|
.curl i{font-style:normal;color:var(--faint)}
|
|
|
|
/* index */
|
|
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
|
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
|
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
|
#q:focus{outline:none;border-color:var(--soft)}
|
|
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
|
text-transform:uppercase;margin:0 0 2rem}
|
|
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
|
padding-bottom:.45rem}
|
|
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
|
border-radius:var(--r-soft);text-decoration:none}
|
|
.row:hover{background:#0a0a0a}
|
|
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
|
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
|
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
|
color:var(--faint);font-size:.85rem}
|
|
footer a{color:var(--soft)}
|
|
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
|
margin:0 0 2rem;font-size:.85rem}
|
|
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
|
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
|
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
|
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
|
.fmap a:hover{text-decoration:underline}
|
|
.fmap div{color:var(--faint);line-height:1.5}
|
|
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
|
|
|
@media (max-width:640px){
|
|
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
|
.btns{gap:.5rem}
|
|
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
|
.copy,.copy .btn{width:100%;justify-content:center}
|
|
.menu{left:0;right:0;min-width:0}
|
|
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
|
.strip b{border-right:0;padding-right:0}
|
|
.bar{width:100%}
|
|
}
|
|
</style>
|
|
<link rel="icon" href="/favicon.svg">
|
|
<link rel="canonical" href="https://hanzoskills.com/hanzo-coursework-fullstack-go-cloud">
|
|
<link rel="alternate" type="text/markdown" href="/hanzo-coursework-fullstack-go-cloud.md">
|
|
<script type="module" src="/webmcp.js"></script>
|
|
</head>
|
|
<!-- Reading this with a machine? Every page here is also plain markdown.
|
|
This one: https://hanzoskills.com/hanzo-coursework-fullstack-go-cloud.md
|
|
Index: https://hanzoskills.com/llms.txt
|
|
Corpus: https://hanzoskills.com/all.md
|
|
Append .md to any path for the markdown twin. -->
|
|
<body>
|
|
<nav><div class="in">
|
|
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
|
<a class="up" href="/">All skills</a>
|
|
</div></nav>
|
|
|
|
<div class="wrap">
|
|
<h1>hanzo-coursework-fullstack-go-cloud</h1><p class="lede">This coursework trains engineering teams migrating from slow, interpreted, memory-heavy environments (Python, Next.js, Node.js, Ruby on Rails) to Hanzo's high-performance native stack (Go, Rust, C++).</p><h1>Coursework: Fullstack Cloud Engineering with Go & Hanzo Base</h1>
|
|
<p><strong>Category</strong>: Hanzo Ecosystem & Engineering Curriculum <strong>Level</strong>: Intermediate to Advanced <strong>Prerequisites</strong>: Familiarity with web services, basic understanding of concurrency. <strong>Related Skills</strong>: <code>hanzo/hanzo-migrate-backend-to-go.md</code>, <code>hanzo/hanzo-base.md</code>, <code>hanzo/hanzo-cloud.md</code>, <code>hanzo/hanzo-tutorial-realtime-sse-backend.md</code>, <code>hanzo/hanzo-examples-native-cloud.md</code></p>
|
|
<hr>
|
|
<h2>Curriculum Overview</h2>
|
|
<p>This coursework trains engineering teams migrating from slow, interpreted, memory-heavy environments (Python, Next.js, Node.js, Ruby on Rails) to Hanzo's high-performance native stack (<strong>Go, Rust, C++</strong>).</p>
|
|
<pre><code>┌─────────────────────────────────────────────────────────────────────────────┐
|
|
│ CURRICULUM: FULLSTACK CLOUD ENGINEERING WITH GO │
|
|
│ │
|
|
│ [MODULE 1] Architectural Foundations & Runtime Shift │
|
|
│ - Why native compiled code wins: Go, Rust & C++ │
|
|
│ - Benchmarking: 15ms cold starts vs 6s Next.js SSR │
|
|
│ │
|
|
│ [MODULE 2] Running Your Own Cloud Locally │
|
|
│ - Base and the open-source cloud, from a checkout │
|
|
│ - start commands: skill.md, On your own machine │
|
|
│ │
|
|
│ [MODULE 3] Realtime SSE Streaming & State Synchronization │
|
|
│ - Native Server-Sent Events (SSE) in Go │
|
|
│ - Zero-overhead streaming without Pusher / external SaaS │
|
|
│ │
|
|
│ [MODULE 4] Extending Hanzo Cloud with `/v1/*` Subsystems │
|
|
│ - Plugin host architecture & ZAP binary transport (HIP-0114) │
|
|
│ - Wiring routes in `manifest/apps.go` │
|
|
│ │
|
|
│ [MODULE 5] Production Observability, Storage & Deployment │
|
|
│ - Embedded SQLite + ClickHouse datastore hybrid │
|
|
│ - Zero-dependency static binary deployments (`CGO_ENABLED=0`) │
|
|
└─────────────────────────────────────────────────────────────────────────────┘</code></pre>
|
|
<hr>
|
|
<h2>Module 1: The Runtime Shift (Python/Next.js to Native Go)</h2>
|
|
<h3>1.1 The Cost of Interpreted Runtimes</h3>
|
|
<p>Interpreted runtimes impose hidden taxes in enterprise environments:</p>
|
|
<ul><li><strong>Python</strong>: The Global Interpreter Lock (GIL) serializes threads; async runtimes (<code>asyncio</code>) suffer from event-loop starvation and heavy memory fragmentation.</li><li><strong>Node.js / Next.js</strong>: Gigabytes of <code>node_modules</code>, cold start latencies (1.5s - 8s), high idle footprint (250MB+ per SSR container), and fragile build tooling.</li><li><strong>Java / Spring</strong>: High JVM memory overhead and slow warmup periods.</li></ul>
|
|
<h3>1.2 The Hanzo Triad</h3>
|
|
<ol><li><strong>Go (<code>github.com/hanzoai/base</code>, <code>github.com/hanzoai/cloud</code>)</strong>:</li></ol>
|
|
<ul><li>Compiles to a single static binary (<code>CGO_ENABLED=0</code>).</li><li>Memory footprint: ~15MB idle.</li><li>Concurrency: Goroutines scheduled on <code>M:N</code> runtime with non-blocking network pollers.</li></ul>
|
|
<ol><li><strong>Rust (<code>hanzoai/engine</code>, <code>hanzoai/reth</code>)</strong>:</li></ol>
|
|
<ul><li>Zero-cost abstractions, deterministic memory safety without GC pauses.</li><li>Inference execution and cryptographic settlement.</li></ul>
|
|
<ol><li><strong>C++ (Metal, CUDA, ANE)</strong>:</li></ol>
|
|
<ul><li>Bare-metal hardware kernels for Apple Silicon and NVIDIA tensor cores.</li></ul>
|
|
<h3>1.3 Lab 1: Profiling Memory & Cold Starts</h3>
|
|
<p>Compare a basic Next.js / FastAPI endpoint against a Go Hanzo Base endpoint:</p>
|
|
<pre><code class="lang-bash"># Build Go binary statically
|
|
CGO_ENABLED=0 go build -ldflags="-s -w" -o ./bin/server ./main.go
|
|
|
|
# Inspect size and launch time
|
|
ls -lh ./bin/server
|
|
time ./bin/server --healthcheck</code></pre>
|
|
<p><em>Expected Result</em>: Binary size < 25MB, startup time < 15 milliseconds.</p>
|
|
<hr>
|
|
<h2>Module 2: Run It Locally</h2>
|
|
<p>Base and the open-source cloud start from a checkout, with no account.</p>
|
|
<h3>The Philosophy</h3>
|
|
<p>Never mock third-party cloud APIs. Run the actual Hanzo services in-process.</p>
|
|
<h3>Lab 2: Launch & Healthcheck</h3>
|
|
<pre><code class="lang-bash"># Base, in a checkout of github.com/hanzoai/base
|
|
go run ./examples/base serve
|
|
curl -i http://127.0.0.1:8090/v1/health # from a second terminal
|
|
|
|
# the cloud, in a checkout of github.com/hanzoai/cloud
|
|
make build && CLOUD_DEV_UNENCRYPTED=1 CLOUD_LISTEN=127.0.0.1:8080 CLOUD_DATA_DIR=.dev/data ./cloud
|
|
curl -s http://127.0.0.1:8080/v1/openapi.json # from a second terminal</code></pre>
|
|
<p>The cloud runs unencrypted this way, for local development only. Every part that runs locally, and what needs the hosted cloud, is in <code>skill.md</code> under <em>On your own machine</em>.</p>
|
|
<hr>
|
|
<h2>Module 3: Realtime Native SSE (Server-Sent Events)</h2>
|
|
<h3>3.1 Why Native SSE Over WebSockets?</h3>
|
|
<ul><li>Built directly on HTTP/1.1 and HTTP/2 (RFC 8895).</li><li>Automatic browser reconnection via <code>Last-Event-ID</code>.</li><li>Zero firewall or proxy websocket-upgrade friction.</li><li>Efficient unidirectional event delivery for LLM tokens, notifications, and analytics.</li></ul>
|
|
<h3>3.2 Implementing the Hub in Go</h3>
|
|
<p>A lock-free, concurrent SSE multiplexer:</p>
|
|
<pre><code class="lang-go">package realtime
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
type Event struct {
|
|
ID string
|
|
Event string
|
|
Data []byte
|
|
}
|
|
|
|
type Hub struct {
|
|
mu sync.RWMutex
|
|
clients map[chan Event]struct{}
|
|
}
|
|
|
|
func NewHub() *Hub {
|
|
return &Hub{
|
|
clients: make(map[chan Event]struct{}),
|
|
}
|
|
}
|
|
|
|
func (h *Hub) Subscribe() chan Event {
|
|
ch := make(chan Event, 64)
|
|
h.mu.Lock()
|
|
h.clients[ch] = struct{}{}
|
|
h.mu.Unlock()
|
|
return ch
|
|
}
|
|
|
|
func (h *Hub) Unsubscribe(ch chan Event) {
|
|
h.mu.Lock()
|
|
delete(h.clients, ch)
|
|
close(ch)
|
|
h.mu.Unlock()
|
|
}
|
|
|
|
func (h *Hub) Broadcast(e Event) {
|
|
h.mu.RLock()
|
|
defer h.mu.RUnlock()
|
|
for ch := range h.clients {
|
|
select {
|
|
case ch <- e:
|
|
default:
|
|
// Client channel full; drop or handle slow consumer
|
|
}
|
|
}
|
|
}
|
|
|
|
func (h *Hub) Handler() http.HandlerFunc {
|
|
return func(w http.ResponseWriter, r *http.Request) {
|
|
flusher, ok := w.(http.Flusher)
|
|
if !ok {
|
|
http.Error(w, "Streaming unsupported", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
w.Header().Set("Cache-Control", "no-cache")
|
|
w.Header().Set("Connection", "keep-alive")
|
|
w.Header().Set("X-Accel-Buffering", "no")
|
|
|
|
ch := h.Subscribe()
|
|
defer h.Unsubscribe(ch)
|
|
|
|
ticker := time.NewTicker(15 * time.Second)
|
|
defer ticker.Stop()
|
|
|
|
for {
|
|
select {
|
|
case <-r.Context().Done():
|
|
return
|
|
case <-ticker.C:
|
|
fmt.Fprintf(w, ": heartbeat\n\n")
|
|
flusher.Flush()
|
|
case e := <-ch:
|
|
if e.ID != "" {
|
|
fmt.Fprintf(w, "id: %s\n", e.ID)
|
|
}
|
|
if e.Event != "" {
|
|
fmt.Fprintf(w, "event: %s\n", e.Event)
|
|
}
|
|
fmt.Fprintf(w, "data: %s\n\n", e.Data)
|
|
flusher.Flush()
|
|
}
|
|
}
|
|
}
|
|
}</code></pre>
|
|
<h3>3.3 Lab 3: Verifying SSE Streams with cURL</h3>
|
|
<pre><code class="lang-bash"># Listen to live stream
|
|
curl -N http://localhost:8090/v1/events/stream</code></pre>
|
|
<hr>
|
|
<h2>Module 4: Extending Hanzo Cloud with <code>/v1/*</code> Subsystems</h2>
|
|
<p>Hanzo Cloud (<code>hanzoai/cloud</code>) uses a host + plugin registry architecture connected via <strong>ZAP Transport</strong> (HIP-0114).</p>
|
|
<h3>4.1 Subsystem Interface</h3>
|
|
<p>Every subsystem implements <code>cloud.Plugin</code>:</p>
|
|
<pre><code class="lang-go">package custom
|
|
|
|
import (
|
|
"net/http"
|
|
"github.com/hanzoai/cloud"
|
|
)
|
|
|
|
func init() {
|
|
cloud.Register("analytics-custom", NewPlugin)
|
|
}
|
|
|
|
type Plugin struct{}
|
|
|
|
func NewPlugin(cfg *cloud.Config) (cloud.Plugin, error) {
|
|
return &Plugin{}, nil
|
|
}
|
|
|
|
func (p *Plugin) Mount(mux *http.ServeMux) {
|
|
mux.HandleFunc("POST /v1/custom/ingest", p.HandleIngest)
|
|
mux.HandleFunc("GET /v1/custom/stats", p.HandleStats)
|
|
}
|
|
|
|
func (p *Plugin) HandleIngest(w http.ResponseWriter, r *http.Request) {
|
|
w.WriteHeader(http.StatusAccepted)
|
|
w.Write([]byte(`{"status":"queued"}`))
|
|
}
|
|
|
|
func (p *Plugin) HandleStats(w http.ResponseWriter, r *http.Request) {
|
|
w.Header().Set("Content-Type", "application/json")
|
|
w.Write([]byte(`{"active_workers":16,"throughput_per_sec":124000}`))
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Module 5: Storage & Observability</h2>
|
|
<h3>5.1 Hybrid Storage</h3>
|
|
<ul><li><strong>Transactional State</strong>: Embedded SQLite (<code>modernc.org/sqlite</code>) for single-binary zero-dependency nodes or PostgreSQL (<code>pgx/v5</code>).</li><li><strong>Telemetry & Logs</strong>: Columnar ClickHouse datastore.</li></ul>
|
|
<h3>5.2 Test-Driven Development (TDD)</h3>
|
|
<p>Every module must ship with automated tests proving correctness:</p>
|
|
<pre><code class="lang-go">// hub_test.go
|
|
package realtime_test
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hanzoai/base/realtime"
|
|
)
|
|
|
|
func TestSSEHub(t *testing.T) {
|
|
hub := realtime.NewHub()
|
|
server := httptest.NewServer(hub.Handler())
|
|
defer server.Close()
|
|
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
|
|
defer cancel()
|
|
|
|
req, _ := http.NewRequestWithContext(ctx, "GET", server.URL, nil)
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
t.Fatalf("Failed to connect to SSE stream: %v", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
t.Errorf("Expected status 200, got %d", resp.StatusCode)
|
|
}
|
|
|
|
if ct := resp.Header.Get("Content-Type"); ct != "text/event-stream" {
|
|
t.Errorf("Expected Content-Type text/event-stream, got %s", ct)
|
|
}
|
|
}</code></pre>
|
|
<hr>
|
|
<h2>Conclusion & Certification</h2>
|
|
<p>By completing this coursework, your engineering team possesses the patterns, tooling, and architectural foundation to:</p>
|
|
<ol><li>Eliminate legacy interpreted runtimes in favor of compiled Go and Rust.</li><li>Build and run offline-ready local cloud environments.</li><li>Stream realtime data natively via SSE.</li><li>Scale seamlessly against Hanzo AI Cloud (<code>hanzo.ai</code> and <code>api.hanzo.ai</code>).</li></ol>
|
|
<footer>
|
|
<div class="fmap">
|
|
<div><b>Build</b>
|
|
<a href="https://hanzo.app">hanzo.app</a> app builder
|
|
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
|
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
|
<div><b>Run</b>
|
|
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
|
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
|
<div><b>Account</b>
|
|
<a href="https://hanzo.id">hanzo.id</a> sign in
|
|
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
|
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
|
<div><b>Company</b>
|
|
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
|
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
|
</div>
|
|
<div class="fend"><a href="/hanzo-coursework-fullstack-go-cloud.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
|
</footer>
|
|
</div></body></html> |