added paged out articles.

paged-out!/nixos-easy-host/.gitignore

@@ -0,0 +1 @@
+*.pdf

paged-out!/nixos-easy-host/main.typ

@@ -0,0 +1,114 @@
+#import "template.typ": article
+
+#show: article.with(
+  title: [Running non Nixpkgs services on NixOS, the lazy way],
+  authors: "Gabe Venberg",
+  date: datetime(year: 2024, month: 12, day: 04),
+  fontsize: 12pt
+)
+
+#show heading.where(level: 2): it => text(size: 12pt, it.body + [:])
+
+NixOS is really nice for self hosting.
+Anything that has a NixOS module can be hosted in a few lines of nix code.
+But what if the service we want to host doesn't come with a NixOS module written for us already in Nixpkgs?
+This is where NixOS can be a little hard, as a guide on setting up a service in Debian or Arch will rarely work on NixOS.
+Of course, the 'nix way' would be to write your own package and module for it, but that can be a daunting task.
+Here are some 'escape hatches' to host some of the simpler services without having to write your own Nix package or module.
+
+#set rect(
+  inset: 8pt,
+  fill: rgb("e4e5ea"),
+  width: 100%,
+)
+
+#grid(columns: (1fr, 2fr), gutter: 5mm,
+  [
+    == Nginx
+    If the application is a simple static website, containing just HTML and JS,
+    the `nginx` module on NixOS provides us with a way to manage virtual hosts complete with https.
+    Shown is how I host my Hugo generated blog.
+  ],
+  rect[
+    ```nix
+    { config, ... }: {
+      services.nginx.virtualHosts."gabevenberg.com" = {
+          enableACME = true;
+          forceSSL = true;
+          root = "/var/www/gabevenberg.com";
+      };
+      security.acme = {
+        acceptTerms = true;
+        defaults.email = "myname@example.com";
+      };
+      networking.firewall.allowedTCPPorts = [443 80];
+    }
+    ```
+  ],
+  grid.cell(
+    colspan: 2,
+    [
+      The complete list of options for virtual hosts can be found here:\
+      #link("https://nixos.org/manual/nixos/stable/options#opt-services.nginx.virtualHosts")
+    ],
+  ),
+
+  [
+    == Docker
+    If the service publishes a Docker image, one can just run that on NixOS.
+    Here's how I host a game server using a premade docker container.
+    Things get a bit more complicated with docker-compose,
+    but one can use #link("https://github.com/aksiksi/compose2nix") to translate a docker-compose.yaml file into a nix file much like the one shown.
+  ],
+  rect[
+    ```nix
+    { config, ... }: {
+      virtualisation.oci-containers = {
+        backend = "docker";
+        containers.factorio = {
+          image = "factoriotools/factorio:stable";
+          volumes = ["/storage/factorio:/factorio"];
+          hostname = "factorio";
+          ports = ["34197:34197/tcp"];
+          environment = {UPDATE_MODS_ON_START = "true";};
+        };
+      };
+      virtualisation.docker.enable = true;
+    }
+    ```
+  ],
+  grid.cell(
+    colspan: 2,
+    [
+      There are, of course, more options for the oci-containers module, found at:\
+      #link("https://nixos.org/manual/nixos/stable/options#opt-virtualisation.oci-containers.containers")
+    ],
+  ),
+
+  [
+    == Systemd
+    Finally, if the service is composed of a single static binary, NixOS makes it really easy to write Systemd services.
+    (I've used a package in Nixpkgs here,
+    but you could just as easily point the Systemd service to a binary you threw in `/opt/` or somewhere.)
+  ],
+  rect[
+    ```nix
+    { config, ... }: {
+      systemd.services.miniserve = {
+        wantedBy = ["multi-user.target"];
+        after = ["network.target"];
+        description = "A directory miniserve instance";
+        environment = {MINISERVE_ENABLE_TAR_GZ="true";}
+        serviceConfig.ExecStart = "${pkgs.miniserve}/bin/miniserve -i 127.0.0.1 -- /storage/miniserve"
+      };
+    }
+
+    ```
+  ],
+  grid.cell(
+    colspan: 2,
+    [
+      And like the last 2 times, the complete list of options for Systemd service can be found here:\
+      #link("https://nixos.org/manual/nixos/stable/options.html#opt-systemd.services")
+    ],
+  ))

paged-out!/nixos-easy-host/template.typ

@@ -0,0 +1,36 @@
+#let article(
+  title: none,
+  authors: (),
+  date: datetime.today(),
+  margin: (x: 1mm, y: 1mm),
+  fontsize: 12pt,
+  doc,
+) = {
+  //setup page size. Margin can be small because Paged Out! includes its own margins.
+  set page(width: 182mm, height: 253mm, margin: margin)
+
+  //blue, web-style links.
+  show link: it => {
+    set text(blue)
+    underline(it)
+  }
+
+  //Lets us fit a bit more text on the page without looking too cramped.
+  set text(size: fontsize)
+  set par(leading: 4pt, justify: true)
+
+  //setup document metadata. (no clue if its useful to the Paged Out! pipeline, but just in case)
+  set document(
+    title: title,
+    author: authors,
+    date: date,
+  )
+
+  //setup top level headings. We leave styling the subheadings to the user.
+  show heading.where(level: 1): set text(size: 16pt)
+
+  //render a title if one is provided.
+  if title != none { [= #title] }
+
+  doc
+}