A Kubernetes (K8s) cluster is not a homogeneous collection of machines. Instead, it consists of a control plane and multiple worker nodes that function as a unified system. This architecture is why we call it a "cluster" - it's a collection of connected computing resources working together.

Important distinctions:

• It's not a "cluster of containers" - containers are what run on the cluster

• It is a "cluster of machines/VPS/VMs" - these form the physical/virtual infrastructure

Cluster Components

Control Plane

The control plane is the brain of the Kubernetes cluster, responsible for maintaining the desired state of the cluster. It includes:

• API Server: The frontend of the control plane

• etcd: The cluster's database and source of truth

• Scheduler: Assigns pods to nodes

• Controller Manager: Manages various controllers

Worker Nodes

Worker nodes are the machines where your containers actually run. Each worker node includes:

• Kubelet: Ensures containers are running in pods

• Kube-proxy: Maintains network rules

• Container Runtime: Software for running containers (Docker, containerd, etc.)

Pod Architecture

In Kubernetes, the pod is the smallest deployable unit (SDU). A pod represents one or more containers that:

• Share the same network namespace (IP address and port space)

• Share the same storage/volumes

• Are scheduled together on the same node

Container Relationship

• One pod can contain one or multiple containers

• Most commonly, a pod contains just a single container

• Containers within a pod are always co-located and co-scheduled

Deployment Patterns

Example Scenario

Let's consider a scenario with Traefik as an ingress controller, a Python ML service, and a Node.js web service.

Option 1: Multi-container Pod Approach

You could put Traefik, the Python ML service, and the Node.js web service all in a single pod. This makes sense if:

• These services always need to be deployed together

• They need to communicate via localhost

• They share a lifecycle (start/stop together)

Option 2: Typical Kubernetes Approach

More commonly, you'd structure this as:

• A Traefik pod (as a DaemonSet or Deployment)

• A Python ML service pod (as a Deployment)

• A Node.js web service pod (as a Deployment)

This separation provides flexibility to:

• Scale each component independently

• Update each component separately

• Have different resource allocations for each service

The Sidecar Pattern

A common multi-container pod use case is the sidecar pattern:

• Main container: Your primary application (e.g., Python ML service)

• Sidecar container: A helper container (e.g., logging or monitoring)

DaemonSets vs Deployments

DaemonSet

• Ensures a copy of a pod runs on every node in the cluster

• Exactly one pod per node

• Automatically adds pods to new nodes

• Used for cluster-wide services like:

  • Node monitoring agents

  • Log collectors

  • Network plugins

  • Storage daemons

Deployment

• Manages a set of identical pods (replicas)

• Pods are distributed across nodes based on available resources

• You specify the desired replica count

• Handles rolling updates and rollbacks

• Used for stateless applications that can be scaled horizontally

When to Use Which

Ask yourself: "Do I need exactly one instance of this service on every node in my cluster?"

• If yes, use a DaemonSet

• If no, use a Deployment

Mental Model Summary

• The cluster consists of physical/virtual machines (nodes)

• Nodes run pods

• Pods contain Docker/OCI containers

This hierarchical structure allows Kubernetes to efficiently manage containerized applications at scale while providing flexibility in deployment strategies.

The word-in-context (WIC) technology at mywords.io helps the reader get the contextual meaning of the word, in both English and French. We help you know a word by the company it keeps, eliminating the need for Google translate, dictionary, or any of technologies which might distract you from the text.

When the reader encounters a sentence, such as this next one from L’Étranger:

J'étais noyé dans le bruit et la poussière.

On clicking noyé, the reader would get the explanation (NOT the translation) in this specific context.

noyé

Overwhelmed or engulfed by something

Submergé ou englouti par quelque chose

Similarly, on clicking bruit, one would get

bruit

Noise or sound

son qui dérange

On clicking poussière:

poussière

Dust or dirt particles

Particules de saleté qui flottent dans l'air

WIC: In the wild Example

Here is a screenshot of another example:

The sentence is:

Mais il le fera sans doute après-demain, quand il me verra en deuil.

On user’s clicking on the word deuil, the translation of the sentence is immediately provided just above the original French text. Simultaneously, the page displays the explanations of the contextual meaning of the word in both languages:

Now this is a funny example — deuil has very little ambiguity in any context. Nevertheless, the reader can still learn how a ‘french-minded’ person would explain the meaning of the word. The expressions used here, such as il s’agit and signe de are both very useful for describing things in general.

WIC-Gin

Gin is good.

On clicking on a deuil, the word is saved to the user’s notebook for review. Subsequently, whenever the user clicks deuil in their notbook, they will see all sentences they’ve read in which the word deuil has appeared. This sentence-word association is achieved via a data indexing algorithm called generalized inverted index (GIN). Gin is good, better than Elasticsearch lol.

The 2 sentences (or better, contexts) where deuil has appeared are as shown in the screenshot.

Conclusion

Word in context technology has been introduced. Examples have been given. Everyone is invited to use the WIC technology and have fun reading French with ease at mywords.io.

Remember: you shall know a word by the company it keeps.

If your postgers is already pooled you can use it very easily with a env var.

import {DATABASE_URL} from "$env/static/private"
import postgres from "postgres";
import {drizzle} from "drizzle-orm/postgres-js";

//...
// postgres-js db
const client = postgres(DATABASE_URL);
// drizzle db
const db = drizzle(client);

However, if the postgres is not pooled, and is running on 5432, then we should use Hyperdrive to pool connections. Otherwise, frequent serverless requests will blow up your postgres. See supabase page on connection pooling at Connect to your database | Supabase Docs

Hyperdrive will be maintained by Cloudflare infra and made as an available binding for your worker or pages functions.

Enabled node_js compat, injest Hyperdrive into hooks.server.ts locals object, and you’re good to go.

The bindings is shown here:

Here hypg is a random name, HYPERDRIVE is the binding var.

https://mywords.io runs with this set up. Have fun.

Idea:

1. having a machine (builder) somewhere that listens for code change in git repo.

2. On change, the builder rebuilds the project with an array of secret variables you gave it

3. Builder sends (scp) the build to the production server.

4. Builder SSH into the production server

5. Builder executes restart on the server.

   Note: Of course there could be a few seconds of down time inter-deployment— not so elegant. But you have no user so whatever bro. I also know how to deploy with no down time, but we are in amateur land here.

Steps:

I. Set up vps env + ssh credentials (production server)

II. Init a sveltekit project (code + repo)

III. configure github and write yml. (repo + secrets + free builder on github)

IV. ship and ship

I. Setting up vps:

1. generate a pair of keys (Generate SSH Key Pair Online)

   

   I’m not using these keys you should not disclose your keys to anyone..

2. put public key on vps in a line in the file:

   /root/.ssh/authorized keys

   ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIB/IABctG2IpNNaeZVXm+yhtDWRXpjX7lZcr9eTHh/ZV noname

   Note I’m using a Linode server with root access. AWS or any other VPS should have some file in some directory for saving entries of public key like this.

   In this Linode context, the meaning of this file is:

   A request with the private key that corresponds to this public key can connect to this vps as root user.

   The private key will be saved in your github action secret, as illustrated in section III

3. install nodejs in vps

   follow this site: install nodejs or nodejs via nvm, which I use in this tutorial

   Use node --version to verify success

4. download and start nginx in vps

   sudo apt install nginx

   and maybe run

    sudo systemctl enable nginx 

   I’m not even sure bro. Ask Claude and see what happens if you’re stuck.

5. open up application firewall port (22, 80)

   

   This is to accepting incoming HTTP request at port 80, the default. HTTPs is a bit different so fuck that.

   quite simple on linode. Outta be easy too on digital ocean, lightsail, EC2, Azure and shit

   22 is opened for us to connect to it.

6. Reverse proxy 80 to 0.0.0.0:3000

   Reverse proxy is a bad name and it does not say anything. It is there to confuse you. Congrats.

   What you want is every request that goes to port 80 should be redirected to this vps’s localhost (0.0.0.0:3000) lol. I’d like to call it request redirect.

   Later we’re gonna run this sveltekit server at 3000

   Add this block to your nginx site conf at /etc/nginx/sites-enabled/default

   or is it site-available? I forgot. Fuck this. Just ask Claude bruv.

   This achieves the reverse proxy. Why is reverse proxy important? Actually you can skip this shit by opening 3000 on firewall too. You’ll learn it’s all good. You’ll learn when it is necessary. Given you have no user there ain’t no probelm.

   location / {
       proxy_pass http://0.0.0.0:3000;
       proxy_set_header Host $host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
   }

7. Verify that nginx is running at your ip: say 3.124.5.66 by typing it into your browser you should see this page.

   

8. Create a daemon (it will not work for now)

   Face your inner demon brotha!

   A daemon is just a process that can is kept alive like the machine itself.

   Create a file called my-demo.service at /etc/systemd/system/

   [Unit]
   Description=Demon App or whatever
   After=network.target
   
   [Service]
   Type=simple
   User=root
   WorkingDirectory=/root/demo
   ExecStart=/root/.nvm/versions/node/v20.17.0/bin/node build
   Restart=always
   RestartSec=10
   
   [Install]
   WantedBy=multi-user.target

II. Setting up sveltekit:

1. initiation: Creating a project • Docs • Svelte

   

2. change adapter to node

   run this to install the adaptor

   npm i @sveltejs/adapter-node

   modify the import in svelte.config.js from

   import adapter from '@sveltejs/adapter-auto';

   to

   import adapter from '@sveltejs/adapter-node';

   then run from root directory

   npm run build

   then

   node build

   to verify it’s runnable.

   You should get:

   Listening on 0.0.0.0:3000

III. Configure github and write action .yml

1. Get a github repo like this one of mine

2. push it up there (see tutorial)

3. ssh into your vps and clone the repo there

   Then cd into demo (assuming it is called demo)

   run

   npm install

   and then maybe

   npm run build

   to see if it can run on the vps lol

   now if you start the daemon we created before it should be running ok:

   sudo systemctl start my-demo

   demo because the service is called my-demo. Don’t confuse the directory with the daemon service. I don’t know who you are and what you know. I’m just writing about all the random things that confuse people here.

4. Write the .yml for github action

   create this file file under .github/workflows directory

   .github/workflows/node.yml

   Again, supposing the project directory is called demo

   so this is demo/.github/workflows/node.yml

   we could have:

   name: Deploy Svelte to Server
   
   on:
     push:
       branches:
         - node
   
   jobs:
     build-and-deploy:
       runs-on: ubuntu-latest
   
       steps:
         - uses: actions/checkout@v4
   
         - name: Setup Node.js
           uses: actions/setup-node@v4
           with:
             node-version: '20'
   
         - name: Install dependencies
           run: |
             npm install
   
         - name: Build project
           run: npm run build
   
         - name: Install SSH key
           uses: shimataro/ssh-key-action@v2
           with:
             key: ${{ secrets.SSH_PRIVATE_KEY }}
             known_hosts: unnecessary
             if_key_exists: replace
   
         - name: Adding Known Hosts
           run: ssh-keyscan -H ${{ secrets.SSH_IP }} >> ~/.ssh/known_hosts
   
         - name: Deploy to server
           run: |
             scp -r build/ root@${{ secrets.SSH_IP }}:/root/demo/
             ssh root@${{ secrets.SSH_IP }} 'nohup systemctl restart demo &'
   

   What this does is:

   • only react to the node branch (set up any branch you’d like)

   • use node 20 to build

   • build

   • ssh into the machine we rent at linode

   • Not sure if it is necessary to add known hosts lol

   • deploy is really just sending the newly built build directory to the desination, which is /root/demo and then restarting that our daemon process without waiting (nohup means no waiting innit?)

   Note that SSH_PRIVATE_KEY and SSH_IP both should be in your github secrets.

   Like this:

   In our story, the SSH_IP is

   3.124.5.66

   and the SSH_PRIVATE_KEY is

   -----BEGIN OPENSSH PRIVATE KEY-----
   b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
   QyNTUxOQAAACAfyAAXLRtiKTTWnmVV5vsobQ1kV6Y1+5WXK/Xkx4f2VQAAAJC7vBvmu7wb
   5gAAAAtzc2gtZWQyNTUxOQAAACAfyAAXLRtiKTTWnmVV5vsobQ1kV6Y1+5WXK/Xkx4f2VQ
   AAAEA6Gub5A7f8Ap4aDZq/vIZ8ZtC7JRkzl2O072hZJi/Sqh/IABctG2IpNNaeZVXm+yht
   DWRXpjX7lZcr9eTHh/ZVAAAABm5vbmFtZQECAwQFBgc=
   -----END OPENSSH PRIVATE KEY-----

   

   You can login to github to configure them or run commands, github action will be able to read them. The entries should be visible in you github repo UI.

OK I think this is enough. It should work.

I deployed mine at https://mywords.io, there is some https nginx tweaks here but not essential.

Thanks for reading.

Bonjour, language nerds and bookworms. Welcome to mywords.io, where I’ve made it my mission to help you read French books without feeling like you’re drowning in a sea of untranslatable nonsense. No flashy promises, no “be fluent in 30 days” nonsense. Just you, some excellent French literature, and a few clever tools to help you enjoy it.

Why Are We Here?

Because reading in another language is hard. And if you’ve ever cracked open Madame Bovary and thought, “Why is every other word a mystery?” I feel you. Inspired by Adele Goldberg’s work on usage-based learning (fancy talk for “context matters”), I built a platform that gives you what you actually need: the ability to figure out what’s going on without constantly Googling words or losing your place.

What Makes mywords.io Cool?

Word-in-Context (WIC) Technology

Here’s the thing about words: they’re sneaky. They don’t always mean the same thing depending on where you find them. That’s where WIC comes in. Click on a word like noyé, and instead of getting a generic translation like “drowned,” you get something better—its actual meaning in the sentence J'étais noyé dans le bruit et la poussière. Spoiler: it’s more like “overwhelmed” here.

WIC works because it reads the room. You get a quick French and English definition that fits the vibe, not just the dictionary.

The screenshot below comes from my personal reading session of the book ‘Psychologie des Foules’ by Le Bon. For words that I’m not 100% sure about, I first predicted their contextual meaning in French in my head, and the clicked on them to verify if they meant indeed what I thought.

Dynamic Word Notebook

Every word you click on? It’s automatically saved in your Vocabulary Notebook, so you can revisit it later when you’re feeling studious (or bored). It’s not just a boring list either; it tracks the different contexts where you found each word. You’ll start seeing patterns, and soon you’ll know these words like old friends.

Save Sentences, Not Just Words

Ever fall in love with a sentence? Or maybe it just baffles you, and you want to come back to it later. Either way, the Sentence Contextualisation feature lets you save entire sentences to your notebook. Because let’s face it, words are better with their friends.

Reverse Index: The Google of French Contexts

Need to see how a particular word behaves in the wild? The Reverse Index feature lets you search for all the contexts where a word shows up in the library. It’s like stalking your favourite word to understand its quirks and habits.

What Can You Read?

I’ve got a growing library of French books, from timeless classics to modern works:

• Le Petit Prince (yes, it’s mandatory)

• Madame Bovary (for when you’re in the mood for some drama)

• Essays by Gustave Le Bon (nerdy, but worth it)

• Modern stuff from Yann LeCun (to be added)

These aren’t just here for show. They’re packed with real, living French—so you can stop reading stilted textbook sentences and start absorbing the good stuff.

So, Why Should You Care?

Because reading in French doesn’t have to feel like running a marathon with a dictionary strapped to your back. mywords.io is here to make it smoother, weirder, and way more enjoyable. You’ll actually start to get French, one beautifully confusing sentence at a time.

No Pressure, Just Books

Sign up if you’re curious. I’m not here to sell you some grand language-learning journey. I’m just a guy who think certain French books are pretty great and want to share the tools that make reading them easier and more fun.

So grab a croissant and dive in. Let’s read some French.

Try it

Subscribe now