DEV Community: Tingwei

yeeKV: A Lightweight Redis-like Key-Value Store in Go

Tingwei — Fri, 15 Aug 2025 15:59:09 +0000

yeeKV is a lightweight Redis-inspired key-value store, perfect for learning and experimentation. It supports core Redis features like strings, lists, and streams, and ensures thread-safe operations, so multiple clients can safely interact with the store concurrently. While it already works well, there’s still plenty of room for more features.

Features

RESP Protocol: Works with Redis clients
Multiple Data Structures: Strings, Lists, Streams
Key Expiration: Millisecond precision (PX)
Thread-Safe: Concurrent access is safe

Quick Start

Start the server:

go build -o yeekv main.go
./yeekv

Use the built-in CLI:

go build -o yeekv-cli cli.go
./yeekv-cli

Example session:

yeeKV> SET foo bar
OK
yeeKV> GET foo
bar
yeeKV> exit
bye~

Roadmap

More Redis commands (DEL, EXPIRE, INCR…)
Optimized storage & memory management
Persistence (RDB / AOF)
Cluster mode & Pub/Sub support

My OOP Implementation of Twitter in C#

Tingwei — Tue, 01 Apr 2025 06:22:37 +0000

I made lots efforts to write this blog !!

Tingwei — Fri, 24 Jan 2025 16:59:18 +0000

How to Build a Logging Pipeline with OpenTelemetry, Grafana Loki, and Grafana in Docker Compose

Tingwei ・ Jan 24

#devops #docker #dotnet #postgres

How to Build a Logging Pipeline with OpenTelemetry, Grafana Loki, and Grafana in Docker Compose

Tingwei — Fri, 24 Jan 2025 16:52:57 +0000

Intro

This application outputs logs to the OpenTelemetry service, which collects them. Then, it pushes the logs to the Grafana Loki service for aggregation and storage. Finally, Grafana is used to visualize and analyze the log data from Grafana Loki.

Configuration

Using the environment variables from docker-compose-config.txt, they are passed into docker-compose.yaml. Additionally, loki-config.yaml is used to configure Grafana Loki, and otel-collector-config.yaml is used to configure the OpenTelemetry collector. Logs are stored in MiniO, while Postgres is used to store Grafana's configuration.

docker-compose.yaml

services:
  # I use .NET 8 to develop the application
  dotnet-app:
    build:
      context: .
      dockerfile: Dockerfile # Remeber to add Dockerfile of the application
    container_name: dotnet-app
    environment:
      ASPNETCORE_URLS: http://+:5000
      DOTNET_LOG_LEVEL: Information
    ports:
      - "${DOTNET_APP_PORT}:5000" # .NET App port
    depends_on:
      - opentelemetry-collector-svc

  # Loki (Log storage)
  loki-svc:
    image: grafana/loki:3.3.2
    container_name: loki-svc
    ports:
      - "3100" # Loki API port
    command: -config.expand-env=true -config.file=/etc/loki/local-config.yaml
    environment:
      MINIO_USER: ${MINIO_USER}
      MINIO_PASSWORD: ${MINIO_PASSWORD}
      MINIO_PORT: ${MINIO_PORT}
    volumes:
      - ./loki-config.yaml:/etc/loki/local-config.yaml
    depends_on:
      - minio-svc

  postgres-grafana-svc:
    image: postgres
    container_name: postgres-grafana-svc
    # set shared memory limit when using docker-compose
    shm_size: 128mb
    environment:
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_DB: ${POSTGRES_GRAFANA_DB}
    ports:
      - "${POSTGRES_GRAFANA_PORT}:5432"
    volumes:
      - postgres_grafana_data:/var/lib/postgresql/data

  # Grafana (Visualization)
  grafana-svc:
    image: grafana/grafana
    container_name: grafana-svc
    ports:
      - "${GRAFANA_PORT}:3000" # Grafana UI port
    environment:
      GF_DATABASE_TYPE: postgres
      GF_DATABASE_HOST: postgres-grafana-svc:5432
      GF_DATABASE_NAME: ${POSTGRES_GRAFANA_DB}
      GF_DATABASE_USER: ${GF_SECURITY_ADMIN_USER}
      GF_DATABASE_PASSWORD: ${GF_SECURITY_ADMIN_PASSWORD}
    depends_on:
      - postgres-grafana-svc
      - loki-svc
    entrypoint:
    - sh
    - -euc
    - |
      mkdir -p /etc/grafana/provisioning/datasources
      cat <<EOF > /etc/grafana/provisioning/datasources/ds.yaml
      apiVersion: 1
      datasources:
      - name: Loki
        type: loki
        access: proxy
        orgId: 1
        url: http://loki-svc:3100
        basicAuth: false
        isDefault: true
        version: 1
        editable: false
      EOF
      /run.sh

  # OpenTelemetry Collector
  opentelemetry-collector-svc:
    image: ghcr.io/open-telemetry/opentelemetry-collector-releases/opentelemetry-collector-contrib:latest
    container_name: opentelemetry-collector-svc
    ports:
      - "4318" # OTLP HTTP port
    volumes:
      - ./otel-collector-config.yaml:/etc/otel-collector-config.yaml
    environment:
      OTEL_LOG_LEVEL: debug
    command:
      - "--config=/etc/otel-collector-config.yaml"
    depends_on:
      - loki-svc

  # MiniO (Object Storage)
  minio-svc:
    image: minio/minio
    container_name: minio-svc
    ports:
      - "${MINIO_PORT}:9000" # MiniO API port
      - "${MINIO_CONSOLE_PORT}:9001" # MiniO Console port for web ui
    environment:
      MINIO_ROOT_USER: ${MINIO_USER}
      MINIO_ROOT_PASSWORD: ${MINIO_PASSWORD}
    command: server /data --console-address ":9001" # 9001 container port
    volumes:
      - minio_data:/data

volumes:
  minio_data:
  postgres_grafana_data:

docker-compose-config.txt

POSTGRES_USER=admin
POSTGRES_PASSWORD=admin
POSTGRES_DB=app
POSTGRES_PORT=15432
POSTGRES_GRAFANA_DB=grafana
POSTGRES_GRAFANA_PORT=15433
DOTNET_APP_PORT=15000
GRAFANA_PORT=15300
GF_SECURITY_ADMIN_USER=admin
GF_SECURITY_ADMIN_PASSWORD=admin
MINIO_PORT=15900
MINIO_CONSOLE_PORT=15901
MINIO_USER=minioadmin
MINIO_PASSWORD=minioadmin

otel-collector-config.yaml

receivers:
  otlp:
    protocols:
      http:
        endpoint: 0.0.0.0:4318


processors:
  batch:

exporters: 
  otlphttp/loki:
    endpoint: http://loki-svc:3100/otlp
    tls:
      insecure: true
  debug:

service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/loki, debug]

loki-config.yaml

auth_enabled: false

server:
  http_listen_port: 3100
  http_server_write_timeout: 310s
  http_server_read_timeout: 310s

common:
  path_prefix: /loki
  storage:
    s3:
      endpoint: minio-svc:9000
      bucketnames: loki-bucket # important !!
      insecure: true
      access_key_id: ${MINIO_USER}
      secret_access_key: ${MINIO_PASSWORD}
      s3forcepathstyle: true # important !!
  replication_factor: 1 # important !!
  ring:
    kvstore:
      store: inmemory

ingester:
  chunk_encoding: snappy
  chunk_idle_period: 2h
  chunk_target_size: 1536000
  max_chunk_age: 2h


querier:
  max_concurrent: 8

schema_config:
  configs:
    - from: "2024-04-01"
      store: tsdb
      object_store: s3
      schema: v13
      index:
        prefix: index_
        period: 24h

compactor:
  working_directory: /loki/compactor

limits_config:
  max_query_parallelism: 24
  split_queries_by_interval: 15m
  ingestion_rate_mb: 20
  ingestion_burst_size_mb: 30
  per_stream_rate_limit: "3MB"
  per_stream_rate_limit_burst: "10MB"
  query_timeout: 300s
  allow_structured_metadata: true

ruler:
  storage:
    type: s3  
    s3:
      endpoint: minio-svc:9000
      bucketnames: loki-rules # important !!
      insecure: true
      access_key_id: ${MINIO_USER}
      secret_access_key: ${MINIO_PASSWORD}
      s3forcepathstyle: true # important !!

In the Application (I used .NET 8)

Install packages

OpenTelemetry
OpenTelemetry.Exporter.OpenTelemetryProtocol
OpenTelemetry.Extensions.Hosting

Program.cs

builder.Logging.ClearProviders().AddConsole().AddOpenTelemetry(options =>
{
    options.IncludeScopes = true;
    options.IncludeFormattedMessage = true;
    options.SetResourceBuilder(ResourceBuilder.CreateDefault()
        .AddService(serviceName: "dotnet-app") // your service name
        .AddAttributes(new Dictionary<string, object>
    {
        // add whatever you want
        ["environment.name"] = "dev",
    }));
    options.AddOtlpExporter(otlpOptions =>
    {
        otlpOptions.Protocol = OpenTelemetry.Exporter.OtlpExportProtocol.HttpProtobuf;
        otlpOptions.Endpoint = new Uri("http://opentelemetry-collector-svc:4318/v1/logs"); // This URL is only for logs, not trace or metric
    });
});

Test

1.start all services, and add two buckets loki-bucket and loki-rules in MiniO

 docker-compose --env-file docker-compose-config.txt up --build -d

2.create logs in app, then go to http://localhost:15300/connections/datasources

3.click "Explore"

4.input service_name = "dotnet-app", Line Contains = "I am Log" (your logs), and click "Run query" (blue button)

5.get the result !

clean all services

docker-compose down -v

Note

In Loki service, it is ok to see like this.

caller=ratestore.go:109 msg="error getting ingester clients" err="empty ring"

References

Loki Exporter: Migration instructions

[Boost]

Tingwei — Tue, 31 Dec 2024 21:16:44 +0000

Hands-on Guide to Sealed Secrets: Deploying .NET 6 Apps Securely in KIND

Tingwei ・ Dec 31 '24

#kubernetes #devops #dotnet #security

Hands-on Guide to Sealed Secrets: Deploying .NET 6 Apps Securely in KIND

Tingwei — Tue, 31 Dec 2024 21:15:39 +0000

Repository

Objective

This guide demonstrates encrypting Kubernetes secrets with Sealed Secrets, using a PostgreSQL connection string as an example, and setting up a local Traefik TLS secret with mkcert.

Prerequisites

KIND
cloud-provider-kind
Sealed Secrets
kubectl
Helm
Traefik
mkcert
.NET 6

Installing Sealed Secrets

Sealed Secrets controller (Cluster-Side Controller)

# by Helm
helm repo add sealed-secrets \
https://bitnami-labs.github.io/sealed-secrets

helm install sealed-secrets -n kube-system  \
--set-string fullnameOverride=sealed-secrets-controller \
sealed-secrets/sealed-secrets

kubeseal (client-side utility)

go install \
github.com/bitnami-labs/sealed-secrets/cmd/kubeseal@main

Creating the sealed secret with Sealed Secrets

Create the Kubernetes secret

kubectl create secret generic ms-dev-secret \
 --dry-run=client -o yaml > appsettings-secret.Development.yaml \
 --from-literal=pg-cluster='Host=your_host_ip;Port=5432;Database=your_database;Username=your_username;Password=your_password'

pg-cluster is the name of the key in the secret.
ms-dev-secret is the name of the secret.

Create the sealed secret from the secret

kubeseal --scope cluster-wide \
< appsettings-secret.Development.yaml -o yaml  \
> appsettings-sealed-secret.Development.yaml

appsettings-sealed-secret.Development.yaml is the sealed secret.
--scope

How to decrypt the sealed secret to the secret

# First, find the sealed secret controller
# Running kubectl get secrets -A will show secrets starting with sealed-secrets-
# For example, sealed-secrets-abc 

kubectl get secrets -A

# Secondly, get the private key "sealed-secret-key.pem"
kubectl get secret -n kube-system sealed-secrets-abc \
 -o jsonpath='{.data.tls\.key}' | base64 --decode \
 > sealed-secret-key.pem

# Finally, decrypt the sealed secret "appsettings-sealed-secret.Development.yaml"
# to the secret "appsettings-secret.Development.yaml"
kubeseal --recovery-unseal \
--recovery-private-key sealed-secret-key.pem  \
< appsettings-sealed-secret.Development.yaml  \
-o yaml > appsettings-secret.Development.yaml

# memo: decode base64 string
echo [base64_string] | base64 --decode

Running cloud-provider-kind

# Run As administrator
cloud-provider-kind

Setting up mkcert

Install the cert/key

# on Windows, I used choco
choco install mkcert
mkcert -install
mkcert localhost 127.0.0.1

localhost.pem is the mkcert cert
localhost-key.pem is the mkcert key

Creating the Kubernetes tls secret for Traefik

kubectl create secret tls localhost-tls-secret \
    --cert=localhost.pem \
    --key=localhost-key.pem \
    --namespace=default

localhost-tls-secret is the tls secret for Traefik

Remove mkcert cert/key

mkcert -uninstall
rm -rf "$(mkcert -CAROOT)"

Configuring Traefik with TLS

Deploy Traefik

helm install -f traefik-values-localhost.yaml \
 traefik traefik/traefik

Update localhost tls from external ip of Traefik

mkcert localhost 127.0.0.1 172.19.0.6

172.19.0.6 is the Traefik external ip given by cloud-provider-kind
remember to rename new key and new cert as "localhost.pem" and "localhost-key.pem"

traefik-values-localhost.yaml

ports:
  web:
    redirectTo:
      port: websecure
tlsStore:
  default:
    defaultCertificate:
      secretName: localhost-tls-secret

Deploying the .NET 6 App with Sealed Secrets

# deploy sealed secret first
kubectl apply -f appsettings-sealed-secret.Development.yaml

# deploy the app
kubectl apply -f deploy.yaml

appsettings-sealed-secret.Development.yaml

---
apiVersion: bitnami.com/v1alpha1
kind: SealedSecret
metadata:
  annotations:
    sealedsecrets.bitnami.com/cluster-wide: "true"
  creationTimestamp: null
  name: ms-dev-secret
  namespace: default
spec:
  encryptedData:
    pg-cluster: AgAjyf765/UaOa80g1Z+30zEQ4Sgu5uLU+9EwKEQ5yiZC+8lczxJERGpq1oMmzdL2jLe9sYT7jREGynPDcczX8Y5tU+ZH4ADiuUgbgjpOCrfOXT68AF2LEMu6JFhu3bqMhLbYL1yUMTxQmf6YP/kvPxZ3kTyWaiQfOuTTwgKwGRT50mOrbYJaMMJxH6HMe4V8kPQ6qbpg9FSU1S6DzHCI+pf0HKg8cuCLUjxOXNL7Bc7X+PqGG3nP/BlF4WVaGvYpVCxC/4IakPZIwSI5mUWRpSabFl1f+rP2OmuEuChm3l9XzYTZyXUAu8f9c/jR4FmnK4DVv0MOMeVhsSFf/eS64l2HC6/evKscL2AIvw2HWX/bpTJeeNfA0neSqNYn4zMMTs2nSFsQTh0Qd5XE/zdprYY74B6UlbcNZHiOAeKiHlo8bL44ulCcZBTWviBejd7dB/ot07l0lfo0aa1F2O/WKT6/gdGNnxULx7weZbwDKjb970OmtJpmS4HKiwf3vnlOoF6tGsPzd7Bj3mXEFnMPFKdnZ/nwsKc8+lVRFBQ5CaWZziXD5T5uOQB/lSUFoY7miCpGEM49INUbfPpZKZd4aW1ZPFJ1bszlkBL2F7gkl3i+vVtqFHqv3DIF5RG/Vk537dppLEsjA3qK0vGjJJzYTCBppyij86PRcI7EjGeDd63YTuHP59U/RKOfCfLdEntuABjWN124N3rpmQB60Tdr84AWVmQG8SUD1dBSii6cGtqNVN8iLqZqAn1cfGQhV0nG56Ciyd+/hTAVIxTAGqvKMXO/OJWTuzZ9X8p0Ry5WgYDWMgwV+Du7gUJ6Bb+kq2TTTOXGKiUXKFu3wl0vj2WpBmZiYV10DNb9k2jlSVx6JA=
  template:
    metadata:
      annotations:
        sealedsecrets.bitnami.com/cluster-wide: "true"
      creationTimestamp: null
      name: ms-dev-secret
      namespace: default

deploy.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ms
  labels:
    app: ms
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ms
  template:
    metadata:
      labels:
        app: ms
    spec:
      containers:
      - name: ms-app
        image: ghcr.io/tingwei628/ms/ms:latest
        ports:
        - containerPort: 10001
        env:
        - name: DOTNET_ENVIRONMENT
          value: Development
        - name: ConnectionStrings__PgCluster
          valueFrom:
            secretKeyRef:
              name: ms-dev-secret
              key: pg-cluster
        - name: ASPNETCORE_URLS
          value: http://+:10001
        livenessProbe:
          httpGet:
            path: /health
            port: 10001
          initialDelaySeconds: 10
          periodSeconds: 5
        readinessProbe:
          httpGet:
            path: /health
            port: 10001
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: ms-service
  labels:
    app: ms
spec:
  selector:
    app: ms
  ports:
    - port: 10001
      targetPort: 10001
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: ms-ingress
  namespace: default
  labels:
    app: ms
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`172.19.0.6`) && PathPrefix(`/ms`)
      kind: Rule
      middlewares:
        - name: strip-ms-prefix
      services:
        - name: ms-service
          port: 10001
---
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: strip-ms-prefix
  labels:
    app: ms
spec:
  stripPrefix:
    prefixes:
      - /ms

port = 10001 (whatever you want)
ConnectionStrings__PgCluster is from the key "pg-cluster" in the secret "ms-dev-secret"

Testing

Done!

Setting Up CloudNativePG on KIND with pgAdmin

Tingwei — Thu, 12 Dec 2024 08:52:43 +0000

1. Install Prerequisites

Install Helm, KIND, kubectl, and pgAdmin4.

2. Create KIND Cluster

Run kind create cluster --name myk8s --config cluster.yaml

### cluster.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
  - role: worker

3. Deploy CloudNativePG Operator

helm repo add cnpg https://cloudnative-pg.github.io/charts
helm repo update
helm install cnpg cnpg/cloudnative-pg --namespace cnpg-system --create-namespace

4. Deploy PostgreSQL Cluster

Run kubectl apply -f postgres.yaml

## postgres.yaml
apiVersion: postgresql.cnpg.io/v1
kind: Cluster
metadata:
  name: pg-cluster
  labels:
    app: pg
spec:
  instances: 3
  storage:
    pvcTemplate:
      accessModes:
        - ReadWriteOnce
      resources:
        requests:
          storage: 1Gi
      storageClassName: standard
      volumeMode: Filesystem
  postgresql:
    parameters:
      shared_buffers: 256MB
---
# pgBouncer
apiVersion: postgresql.cnpg.io/v1
kind: Pooler
metadata:
  name: pg-pooler
  labels:
    app: pg
spec:
  cluster:
    name: pg-cluster
  instances: 3
  type: rw
  serviceTemplate:
    metadata:
      labels:
        app: pg
    spec:
      type: LoadBalancer
  pgbouncer:
    poolMode: session
    parameters:
      max_client_conn: "1000"
      default_pool_size: "10"

5. Install Kubernetes Cloud Provider for KIND

Installation
Control-plane nodes need to remove the label to access workloads via a LoadBalancer service.

kubectl label node myk8s-control-plane node.kubernetes.io/exclude-from-external-load-balancers-

Run As administrator

cloud-provider-kind

6. Connect to PostgreSQL with pgAdmin4

Open pgAdmin4, create a new server with PostgreSQL connection details

EXTERNAL-IP

kubectl get svc pg-pooler

Password (pg-cluster-app)

kubectl get secret pg-cluster-app -o yaml
## check data.password
echo <password> | base64 -d

host=<External IP>
port=5432
database=app
user=app
password=<password>

References

I made an URL shortener

Tingwei — Fri, 06 Dec 2024 10:38:23 +0000

Repository

Features

sha256
TTL
Rate limiter
SQLite3

Flow

In this article, I walk through the process of setting up k0s on a VPS and configuring Traefik as a reverse proxy with HTTPS enabled using Cloudflare Origin CA Certificates

Tingwei — Tue, 03 Dec 2024 06:41:38 +0000

Deploying Traefik Proxy with Cloudflare Origin CA Certificate on k0s

Tingwei ・ Dec 3 '24

#devops #kubernetes #webdev #cloud

Deploying Traefik Proxy with Cloudflare Origin CA Certificate on k0s

Tingwei — Tue, 03 Dec 2024 06:09:55 +0000

Objective:

To perform a minimal installation of k0s on a VPS, set up Traefik as a reverse proxy, and enable HTTPS.

Prerequisites:

A VPS (4GB RAM, 2 vCPUs)
A domain
k0s (v1.31.2+k0s.0)
Helm (v3.16.3)
MetalLB (v0.14.8)
Traefik (v3.2.0)
Traefik Helm Chart (v33.0.0)

Steps:

1. k0s Setup:

A single-node k0s installation is ideal for this minimal VPS setup to minimize resource usage. Below are the installation commands:

Download k0s

curl --proto '=https' --tlsv1.2 -sSf https://get.k0s.sh | sudo sh

Install a single node k0s

# output k0s.yaml
sudo k0s config create > k0s.yaml

Modify k0s.yaml to install MetalLB

  extensions:
    helm:
      concurrencyLevel: 5
      repositories:
        - name: metallb
          url: https://metallb.github.io/metallb
      charts:
        - name: metallb
          chartname: metallb/metallb
          version: "0.14.8"
          namespace: default

Start k0s

sudo k0s install controller --single --force --config k0s.yaml

sudo k0s start

Create ConfigMap for MetalLB

Remember to add your vps public ip

---
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: metallb-ip-pool
  namespace: default
spec:
  addresses:
    - [your_vps_public_ip]/32
---
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: metallb-l2-advertisment
  namespace: default
spec:
  ipAddressPools:
    - metallb-ip-pool

After adding metallb-l2-pool.yaml, then

kubectl delete validatingwebhookconfigurations.admissionregistration.k8s.io metallb-webhook-configuration

kubectl apply -f metallb-l2-pool.yaml

Why kubectl delete validatingwebhookconfigurations.admissionregistration.k8s.io metallb-webhook-configuration

2. Enabling HTTPS and Redirect HTTP to HTTPS:

Generate a Cloudflare Origin CA certificate for secure HTTPS
How to generate your Origin certificate on Cloudflare
Create TLS secret your-tls-secret
- your_origin_ca.pem (Origin Certificate)
- your_origin_ca.key (Private Key)

kubectl create secret tls your-tls-secret --cert=your_origin_ca.pem --key=your_origin_ca.key --namespace=default

3. Installing Traefik:

Install Traefik using the Helm chart.

Install Helm
Add your traefik_values.yaml
- my-tls-secret is generated from the previous step.
- redirectTo is used for redirecting HTTP to HTTPS.
- nodeAffinity is because we need to schedule traefik pod in the controller node.

#  traefik_values.yaml
ports:
  web:
    redirectTo:
      port: websecure
tlsStore:
  default:
    defaultCertificate:
      secretName: my-tls-secret
affinity:
  nodeAffinity:
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
        - matchExpressions:
            - key: node-role.kubernetes.io/control-plane
              operator: Exists

Then

helm repo add traefik https://traefik.github.io/charts

helm install -f traefik_values.yaml traefik traefik/traefik

4. Test Deployment:

Deploy a simple whoami application to test if the setup is successful.

Add your whoami.yaml
- port = 8001 (or whatever you want)
- WHOAMI_PORT_NUMBER is necessary

apiVersion: apps/v1
kind: Deployment
metadata:
  name: whoami
  namespace: default
  labels:
    app: whoami
spec:
  replicas: 1
  selector:
    matchLabels:
      app: whoami
  template:
    metadata:
      labels:
        app: whoami
    spec:
      containers:
        - name: whoami
          image: traefik/whoami
          env:
            - name: WHOAMI_PORT_NUMBER
              value: "8001"
---
apiVersion: v1
kind: Service
metadata:
  name: whoami-service
  namespace: default
  labels:
    app: whoami
spec:
  ports:
    - port: 8001
      targetPort: 8001
  selector:
    app: whoami
---
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: whoami-ingress
  namespace: default
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`your_domain`) && PathPrefix(`/whoami`)
      kind: Rule
      services:
        - name: whoami-service
          port: 8001

Then

kubectl apply -f whoami.yaml

So, you would see the whoami app from the url your_domain/whoami

References:

I made a hobby OS

Tingwei — Tue, 12 Nov 2024 21:15:32 +0000

Repository

Features

Support for long mode
Interrupt and exception handling
Printing characters on the screen
Memory manager with paging mechanism
2MB page size support under 4-level paging
Timer handler for process management
Process manager for process scheduling
System call interface
PS/2 keyboard driver
Command-line interface for interacting with the OS kernel
FAT16 file system support

[Deprecated] The payment test with a Telegram bot

Tingwei — Sun, 27 Feb 2022 21:59:29 +0000

This post is not working anymore !!!

I wrote a bot in Go to test the payment with Stripe.

More details in Repo