The HTTP server that can be terminated (/quit, Ctrl+C, docker stop, all tested).

Author: dkorolev

step02_server/Dockerfile

@@ -0,0 +1,23 @@
+# Build the binaries statically, and then run them from a separate container.
+FROM alpine AS build
+
+# Intentionally not installing `cargo`, etc. But it does need `clang`.
+RUN apk add rustup clang musl
+
+# Init local rust via `rustup`, including static targets builder.
+RUN rustup-init -y -t x86_64-unknown-linux-musl --no-modify-path 
+RUN mv /root/.cargo/bin/* /usr/local/bin/
+
+# Build the project.
+COPY ./code /code
+WORKDIR /code
+RUN cargo build --release --target x86_64-unknown-linux-musl
+
+# Prepare the static binary.
+RUN cp ./target/x86_64-unknown-linux-musl/release/httpserver /
+
+# The resulting container with the static binary only.
+FROM scratch
+COPY --from=build /httpserver /httpserver
+EXPOSE 3000
+ENTRYPOINT ["/httpserver"]

step02_server/code/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "httpserver"
+edition = "2021"
+
+[dependencies]
+axum = "0.7"
+hyper = { version = "1", features = ["server", "http1"] }
+tokio = { version = "1", features = ["full"] }

step02_server/code/src/main.rs

@@ -0,0 +1,44 @@
+use axum::{routing::get, Router, serve};
+use std::net::SocketAddr;
+use tokio::{net::TcpListener, sync::mpsc};
+use tokio::signal::unix::{signal, SignalKind};
+
+#[tokio::main]
+async fn main() {
+  let (shutdown_tx, mut shutdown_rx) = mpsc::channel::<()>(1);
+
+  let app = Router::new()
+    .route("/healthz", get(|| async { "OK\n" }))
+    .route("/", get(|| async { "hello this is a rust http server\n" }))
+    .route(
+        "/quit",
+        get({
+          let shutdown_tx = shutdown_tx.clone();
+          move || {
+            let shutdown_tx = shutdown_tx.clone();
+            async move {
+              let _ = shutdown_tx.send(()).await;
+              "yes i am shutting down\n"
+            }
+          }
+        }));
+
+  let addr = SocketAddr::from(([0, 0, 0, 0], 3000));
+  let listener = TcpListener::bind(addr).await.unwrap();
+
+  println!("rust http server ready on {}", addr);
+
+  let server = serve(listener, app);
+
+  let mut term_signal = signal(SignalKind::terminate()).expect("failed to register SIGTERM handler");
+  let mut int_signal = signal(SignalKind::interrupt()).expect("failed to register SIGINT handler");
+
+  tokio::select! {
+    _ = server.with_graceful_shutdown(async move { shutdown_rx.recv().await; }) => { println! ("done"); }
+    _ = tokio::signal::ctrl_c() => { println!("terminating due to Ctrl+C"); }
+    _ = term_signal.recv() => { println!("terminating due to SIGTERM"); }
+    _ = int_signal.recv() => { println!("terminating due to SIGINT"); }
+  }
+
+  println!("rust http server down");
+}

step02_server/run.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+set -e
+
+docker build . -t demo
+
+docker run --rm --network=bridge -p 3000:3000 -t demo &
+PID=$!
+
+while true ; do
+  R="$(curl -s localhost:3000/healthz || echo NOPE)"
+  if [ "$R" = "OK" ] ; then
+    echo "server healthy"
+    break
+  fi
+  sleep 0.5
+  echo "server not yet healthy"
+done
+
+curl -s localhost:3000
+
+curl -s localhost:3000/quit
+
+wait $PID