FastCGi tinkering was a fun waste of time

_posts/2021-06-27-remember-fastcgi.md

@@ -0,0 +1,98 @@
+---
+layout: post
+title: "Remember FastCGI?"
+tags:
+- rust
+---
+
+
+"Serverless" is sometimes referred to as "cgi-bin" which isn't entirely fair as
+it's somewhere between cgi-bin and FastCGI.  Somewhere along the way both faded
+from memory. While goofing off last weekend wondered to myself: is
+[FastCGI](https://en.wikipedia.org/wiki/FastCGI) still useful? Unlike the
+classic cgi-bin approach where a script or program was executed for each
+individual request, FastCGI is a binary protocol which allows for longer lived
+processes serving multiple requests. It continues to be used in the PHP
+community but seems to have largely fallen out of favor. Nonetheless I decided
+to tinker a little bit with FastCGI in Rust.
+
+
+The most sensible crate that I found was the [fastcgi](https://github.com/mohtar/rust-fastcgi) and played around a bit.
+The crate is a bit old and I needed to do some fiddling to get a simple example compiling:
+
+```rust
+extern crate fastcgi;
+
+use std::io::Write;
+use std::net::TcpListener;
+use log::*;
+
+fn main() -> std::io::Result<()> {
+    pretty_env_logger::init();
+    let listener = TcpListener::bind("127.0.0.1:8010")?;
+    info!("Listening on 8010");
+
+    fastcgi::run_tcp(|mut req| {
+        info!("Handling request");
+        for param in req.params() {
+            info!("{:?}", param);
+        }
+
+        write!(&mut req.stdout(), "Content-Type: text/plain\n\nHello, world!")
+        .unwrap_or(());
+    }, &listener);
+
+    Ok(())
+}
+```
+
+
+In order to test out my little FastCGI server I spun up nginx in Docker which required a little bit of configuration in the `nginx.conf`:
+
+```
+server {
+    listen 8080;
+
+    location / {
+        include /etc/nginx/fastcgi_params;
+        fastcgi_pass 127.0.0.1:8010;
+    }
+}
+```
+
+After about 45 minutes of tinkering around I had an end-to-end example working
+and arrived at the conclusion that if I was going to do all this process
+management and web server configuration, how is this any better than just
+running an embedded web server?
+
+A functionally identical Rust program using
+[Tide](https://github.com/http-rs/tide) looks something like this:
+
+```rust
+#[async_std::main]
+async fn main() -> Result<(), std::io::Error> {
+    tide::log::start();
+    let mut app = tide::new();
+    app.at("/").get(|_| async { Ok("Hello, world!") });
+    app.listen("127.0.0.1:8080").await?;
+    Ok(())
+}
+```
+
+Unlike the FastCGI version, I can hit this directly when testing and do not require a local web server. Though, if I do wish to put this behind nginx, the configuration is quite similar:
+
+```
+server {
+    listen 8080;
+
+    location / {
+        proxy_pass 127.0.0.1:8080;
+    }
+}
+```
+
+If you find yourself with a scripted language where processing HTTP requests
+might be too slow or unsafe, I can still see some utility for FastCGI. For most
+of the rest of us, HTTP won, just write little HTTP webservers.
+
+