Hi everyone,

I'm setting up a small homelab CI/CD environment and I'm trying to understand the best way to run Gitea Actions on Kubernetes without installing Docker on the Kubernetes nodes.

My setup

• Kubernetes: v1.34.10
• Nodes: 1 control-plane + 2 workers
• OS: Ubuntu 26.04
• Container runtime: containerd 2.2.2
• Gitea: 1.27.0
• Gitea is running in Kubernetes
• Gitea Actions runner: gitea/act_runner:latest
• Runner is also running as a Kubernetes Deployment
• Persistent storage: Longhorn
• No Docker installed on the Kubernetes nodes
• ctr is available and /run/containerd/containerd.sock exists

The runner itself registers and works correctly.

The problem

My runner is currently configured with:

runner:
  file: /data/.runner
  capacity: 1
  timeout: 3h

  labels:
    - "ubuntu-latest:host"

A simple workflow like:

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout repository
        uses: actions/checkout@v4

      - name: Show test.py
        run: cat test.py

fails at checkout with:

Cannot find: node in PATH

I understand why this happens: with ubuntu-latest:host, the workflow is executed directly in the runner environment, and the gitea/act_runner image doesn't contain Node.

Gitea's documentation suggests using something like:

labels:
  - "ubuntu-latest:docker://node:22-bookworm"

which would execute the job inside a separate container.

But here's where I'm confused

My Kubernetes nodes already use containerd:

containerd://2.2.2

and have:

/run/containerd/containerd.sock

but no Docker daemon:

docker  -> not installed
nerdctl  -> not installed
ctr     -> available

Why does the standard act_runner container execution model require Docker/Docker API access instead of being able to use the existing containerd runtime?

I'd rather not install Docker on the Kubernetes nodes just to provide CI job containers when Kubernetes is already perfectly capable of creating containers through containerd.

What I'm ultimately trying to achieve

The immediate goal is just:

Gitea
  ↓
Gitea Actions
  ↓
checkout repository
  ↓
run tests

But eventually I want the pipeline to do:

checkout
  ↓
tests
  ↓
build Docker/OCI image
  ↓
push image to registry
  ↓
Argo CD deploys it

So I need a sensible way to get isolated CI job environments containing things like Node, Python, Git, build tools, etc.

Questions

1. Is there a supported way to make act_runner create job containers using containerd directly?
2. If not, is the recommended solution to install Docker on a Kubernetes worker solely for act_runner?
3. Would Gitea Actions Runner Controller / Kubernetes-native runners be a better solution for this setup?
4. What is the recommended architecture for Gitea Actions on a Kubernetes cluster whose runtime is containerd and where I don't want to install Docker?

TLDR : I'm running Gitea 1.27 + act_runner 0.6.1 on Kubernetes 1.34 with containerd 2.2, and I don't have Docker installed on the nodes. ubuntu-latest:host works for the runner itself but actions/checkout@v4 fails because Node isn't available. Gitea's docker:// execution mode looks like the right way to provide a proper job environment, but it expects Docker-compatible execution. I'm considering Docker-in-Docker inside the runner pod so I don't have to install Docker on the Kubernetes hosts, but I'm wondering whether that's the right approach or whether I should use containerd directly or Gitea's Kubernetes-native Runner Controller instead.

I'm mainly looking for the cleanest Kubernetes-native approach rather than just making the immediate checkout test work.

Hey everyone, I'm pretty new to Kubernetes, so please take my questions with a grain of salt. I'm building a homelab where I already have a small Kubernetes cluster, and I'm trying to build a fully self-hosted platform around it: Gitea for Git hosting, Harbor for containers, and runners. Gitea needs persistent storage for repositories and application data, while Harbor can use persistent volumes or delegate object storage to something like MinIO.

This is mainly for learning, so performance isn't really important at this scale. But I keep thinking about how I'd design it in a real environment. Would it be better to run the database and object storage on dedicated machines outside Kubernetes and have the Kubernetes workloads consume them over the network, similar to using managed PostgreSQL/S3 in the cloud? My concern is that if PostgreSQL or MinIO runs on the same worker nodes as the applications, a node failure could affect both compute and storage. Kubernetes has StatefulSets, PVCs, Longhorn/Rook, etc. to address this, but I'm wondering where the practical boundary is and whether externalizing storage is actually considered best practice.

Questions

• Is running PostgreSQL/MySQL or MinIO inside Kubernetes considered an anti-pattern?
• At what scale does it make sense to move them outside the cluster?
• Is mixing stateful and stateless workloads on the same workers a bad practice?
• How much protection do StatefulSets + PVCs + Longhorn/Rook provide against node failure?
• Is there a meaningful performance difference between keeping compute/storage together vs. dedicated storage machines?
• In production, is it more common to keep databases/object storage outside Kubernetes?
• If both approaches can provide HA, what are the main reasons to choose one over the other?

TL;DR

I'm building a small self-hosted Gitea + Harbor + runners platform on my homelab Kubernetes cluster. Is running PostgreSQL and MinIO inside the same Kubernetes cluster a legitimate architecture, or should databases/object storage generally be externalized? I'm mainly trying to understand the real-world trade-offs around HA, node failure, storage/compute separation, performance, and operational complexity.

Hey, does anyone know if playing the Android version of TFT through Waydroid on Linux can get your account banned?

Hi everyone,

I'm trying to understand how Docker image layers are stored and shared.

Let's say I have two different microservices, each with its own Dockerfile:

users-service/Dockerfile

FROM ubuntu:22.04
COPY users-app /app/

orders-service/Dockerfile

FROM ubuntu:22.04
COPY orders-app /app/

Assume the Ubuntu base layer is 200 MB.

My initial understanding is:

users-service image:
    ubuntu layer      200 MB
    users app layer   200 MB
    total             400 MB


orders-service image:
    ubuntu layer      200 MB
    orders app layer  100 MB
    total             300 MB

So each image appears to contain its own Ubuntu base layer.

But when both images exist on the same machine, does Docker actually store:

ubuntu layer        200 MB
users app layer     200 MB
orders app layer    100 MB

(total 500 MB)

or does it store:

users image         400 MB
orders image        300 MB

(total 700 MB)?

My confusion is: if the Dockerfiles are completely separate and both use:

FROM ubuntu:22.04

how does Docker know that the Ubuntu layer is the same and can be reused?

Where is this sharing tracked? Is it based on image names/tags, layer hashes, manifests, or something else?

Also, if the same image is pulled on different machines, does each machine download and store its own copy of the base layers?

Thanks!

Hey everyone, I’m going through my first titre de séjour renewal after entering France with a long-stay visa, and during the process the prefecture unexpectedly asked me for my birth certificate (acte de naissance), even though it wasn’t listed in the original required documents and I already submitted everything else in French. I’m a bit confused because some friends in the same situation didn’t get this request and already had their applications approved without it, so I’m wondering if this is normal random processing, an extra identity check, or just a case-by-case decision from the agent.

Hey everyone,

I'm a 24-year-old male, 180 cm and 78 kg, and I started running about 3 weeks ago with no running background.

I've only done 3 runs so far, roughly one week apart. My first ever run was 3 km at 5:37/km pace. One week later I ran 4 km in 22:28, also averaging 5:37/km. This week I ran 4.61 km in 25:05 at a 5:26/km pace. I attempted a 5K and my splits were 5:36, 5:19, 5:06, 5:16,

The route had around 74 m of elevation gain near the end, and before the climb started I was still running at roughly 5:21/km pace, but the uphill completely broke my rhythm and I ended up walking briefly before stopping.I walked for about 42 minutes and then ran another 2 km at 5:03/km and 5:13/km pace.

Given that I've only been running for 3 weeks and have completed just 3 runs in total, do these results seem decent? Does the uphill look like the main reason my 5K attempt fell apart, or was it more likely a pacing issue? Also, what would be a realistic 5K goal if I keep training consistently?

I am trying to understand FastAPI deployment and whether it has an equivalent of a build artifact like other frameworks. In Angular, after building the project we get a dist folder, and in Spring Boot we get a packaged jar file that is deployed and executed. In FastAPI, it feels like there is no explicit build step and no single output artifact, and instead we just deploy the same project folder, install dependencies, and run the application using a command like uvicorn or gunicorn. My question is whether this is the normal and correct approach in production FastAPI applications, or if there is an equivalent concept of a deployment artifact that should be generated before deployment, similar to frontend or Java backend workflows.

Hey everyone, I’m learning DevOps on my own by building a small project with Docker (frontend, backend, nginx reverse proxy) deployed on AWS EC2 using GHCR. I understand CI as the process of automating things like build, test, lint, and pushing artifacts or Docker images. What I’m confused about is whether CI is usually considered one unified pipeline, or if there are actually different CI flows in practice (for example one for pull requests running checks, and another for building and publishing images after merge), or if it’s typically just one pipeline with conditional stages depending on branches.

For CD, in my setup I deploy to an EC2 instance that is manually configured with Docker and Docker Compose, and then I update the running containers using the latest images. I’m trying to understand what CD looks like in real environments beyond this kind of setup, and also where tools like Terraform actually start to become useful in real projects, since for small setups it feels like overkill and I’m not sure when it becomes a standard part of the workflow.

I’ve been seeing a lot of travel videos lately, and honestly… I’m blown away every time someone discovers Tunisian food.

I always knew our cuisine was good, but watching outsiders explore it made me realize just how insanely rich and underrated it is. From street food to homemade dishes, there’s so much variety and depth.

You’ve got things like kafteji, s7an tounsi, lablebi, fricassé, kaskrout lablebi, brik, dro3, sa7fa, 3ejja, slata mechwia , ojja merguez, chakchouka, tajine , mloukhiya , hargma , kamounia , kaskrout 3ayari , hrissa , ma9loub , … and then the classics like couscous with fish, rouz jerbi, and ksoski bel besbes. And that’s not even scratching the surface.

Every region has its own twist, its own flavors, its own identity. What really stands out to me is how unique it is compared to even our neighbors. It’s this mix of Mediterranean, Arab, Berber, and even Ottoman influences, but it still feels completely its own.

I’m genuinely starting to think Tunisian cuisine deserves to be ranked among the best in the world, and I don’t even feel like I’m exaggerating.

Is it just me being biased, or is Tunisian food seriously underrated globally?

Hi everyone,

I’m working on a deep learning model and I noticed something strange.

When I compare different precisions: FP32 (baseline)

FP16 , INT8 (post-training quantization)

I’m getting better inference accuracy with INT8 than FP16, which I didn’t expect.

I thought FP16 should be closer to FP32 and therefore more accurate than INT8, but in my case INT8 is actually performing better.

Has anyone seen this before? What could explain INT8 outperforming FP16 in inference?

Setup details:

Model exported via ONNX

FP16 used directly / INT8 via quantization

No major architecture changes

Salut à tous,

J’ai une question concernant la gratification de stage en France.

Si une gratification mensuelle est fixée dans la convention (pour un temps plein), comment est-elle réellement calculée pour un mois donné ?

• Est-ce qu’il y a un taux horaire fixe derrière, et donc le montant varie selon le nombre d’heures réellement travaillées (par exemple si on commence en milieu de mois) ?
• Ou bien est-ce qu’on reçoit le même montant mensuel, peu importe le nombre exact d’heures effectuées ?

Aussi, quand le montant est indiqué en brut :

• Est-ce qu’on reçoit exactement cette somme si on n’est pas imposable ?
• Ou bien y a-t-il quand même des cotisations sociales qui sont déduites, même pour un stagiaire ?

Merci d’avance pour vos éclaircissements