dockerize

Dockerfile

@@ -0,0 +1,73 @@
+# syntax=docker/dockerfile:1
+
+# Comments are provided throughout this file to help you get started.
+# If you need more help, visit the Dockerfile reference guide at
+# https://docs.docker.com/engine/reference/builder/
+
+################################################################################
+# Create a stage for building the application.
+
+ARG RUST_VERSION=1.89.0
+FROM rust:${RUST_VERSION}-slim-bullseye AS build
+ARG TARGET=release
+ARG APP_NAME=urls-txt
+WORKDIR /app
+
+RUN rm /var/lib/dpkg/info/libc-bin.* && apt-get clean && apt-get update && apt install libc-bin
+
+# Build the application.
+# Leverage a cache mount to /usr/local/cargo/registry/
+# for downloaded dependencies and a cache mount to /app/target/ for 
+# compiled dependencies which will speed up subsequent builds.
+# Leverage a bind mount to the src directory to avoid having to copy the
+# source code into the container. Once built, copy the executable to an
+# output directory before the cache mounted /app/target is unmounted.
+RUN --mount=type=bind,source=src,target=src \
+    --mount=type=bind,source=Cargo.toml,target=Cargo.toml \
+    --mount=type=bind,source=Cargo.lock,target=Cargo.lock \
+    --mount=type=cache,target=/app/target/ \
+    --mount=type=cache,target=/usr/local/cargo/registry/ \
+    <<EOF
+set -e
+echo TARGET=$TARGET
+echo APP_NAME=$APP_NAME
+[ "$TARGET" = "release" ] && cargo build --locked --release || cargo build --locked
+cp ./target/$TARGET/$APP_NAME /bin/server
+EOF
+
+################################################################################
+# Create a new stage for running the application that contains the minimal
+# runtime dependencies for the application. This often uses a different base
+# image from the build stage where the necessary files are copied from the build
+# stage.
+#
+# The example below uses the debian bullseye image as the foundation for    running the app.
+# By specifying the "bullseye-slim" tag, it will also use whatever happens to    be the
+# most recent version of that tag when you build your Dockerfile. If
+# reproducability is important, consider using a digest
+# (e.g.,    debian@sha256:ac707220fbd7b67fc19b112cee8170b41a9e97f703f588b2cdbbcdcecdd8af57).
+FROM debian:bullseye-slim AS final
+RUN rm /var/lib/dpkg/info/libc-bin.* && apt-get clean && apt-get update && apt install libc-bin
+ENV URLS_TXT_BIND_ADDRESS=0.0.0.0:3000
+
+# Create a non-privileged user that the app will run under.
+# See https://docs.docker.com/develop/develop-images/dockerfile_best-practices/   #user
+ARG UID=10001
+RUN adduser \
+    --disabled-password \
+    --gecos "" \
+    --home "/nonexistent" \
+    --shell "/sbin/nologin" \
+    --no-create-home \
+    --uid "${UID}" \
+    appuser
+USER appuser
+
+# Copy the executable from the "build" stage.
+COPY --from=build /bin/server /bin/
+
+# Expose the port that the application listens on.
+EXPOSE 8000
+
+# What the container should run when it is started.
+CMD ["/bin/server", "/urls.txt"]

compose.yaml

@@ -0,0 +1,9 @@
+services:
+  site:
+    build:
+      context: .
+      target: final
+    ports:
+      - 3000:3000
+    volumes:
+      - "./urls.txt:/urls.txt"

readme.md

@@ -26,6 +26,13 @@ a _really_ simple url shortener: less than 200 lines of Rust and one dependency
    urls-txt path/to/urls.txt
    ```
 
+   the default bind address is `127.0.0.0:3000`.
+   this can be changed using the environment variable `URLS_TXT_BIND_ADDRESS`.
+
+## usage (docker)
+
+a working [dockerfile](./Dockerfile) and [compose file](./compose.yaml) are provided.
+
 ## why?
 
 all url shorteners i've come across are too complicated:
@@ -56,9 +63,8 @@ pls.cx {
 ```
 location / { return 301 http://alv.cx; }
 location /urls-txt { return 301 https://git.alv.cx/alvierahman90/urls-txt; }
-
 ```
 
-##### apache
+#### apache
 
 there's probably a way ¯\_(ツ)_/¯

src/main.rs

@@ -81,8 +81,19 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         println!("USAGE: {} <urls.txt>", args[0]);
         Err("Incorrect arguments")?
     }
+    let urls_filename = args[1].clone();
 
-    let config = spawn_blocking(|| std::fs::read_to_string("urls.txt")).await??;
+    let bind_address = match env::var("URLS_TXT_BIND_ADDRESS") {
+        Ok(addr) => addr,
+        Err(env::VarError::NotPresent) => "127.0.0.1:3000".to_string(),
+        Err(e) => {
+            println!("Failed to read environment variable URLS_TXT_BIND_ADDRESS: {e}");
+            Err(e)?
+        }
+
+    };
+
+    let config = spawn_blocking(move || std::fs::read_to_string(urls_filename)).await??;
     let mut urlmap = HashMap::new();
     for url_pair in config.split('\n') {
         if url_pair.len() == 0 {
@@ -105,7 +116,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let urlmap = Arc::new(urlmap);
 
     println!("Starting TCP Listener...");
-    let listener = TcpListener::bind("127.0.0.1:3000").await?;
+    let listener = TcpListener::bind(&bind_address).await?;
     loop {
         let (socket, _addr) = listener.accept().await?;
         let urlmap = urlmap.clone();