A Simple Solution for Serving ads.txt with Ghost

Introduction

When using Ghost, a modern and powerful content management system, I encountered an issue while trying to implement the ads.txt file. Ghost doesn’t natively support serving static files like ads.txt at the root level without additional configuration, and I needed a solution to comply with Google AdSense policies. After considering various options, I decided to deploy a lightweight NGINX container to handle this specific requirement.

In this article, I’ll walk you through how I solved this challenge using Kubernetes to set up a dedicated NGINX deployment for serving ads.txt.

The Problem

Google AdSense requires the ads.txt file to be served at the root of your domain (e.g., https://example.com/ads.txt). However, Ghost primarily handles dynamic routes for posts and pages, and adding static files like ads.txt directly at the root is not straightforward. Although there are workarounds within Ghost, such as modifying routes or using custom themes, these approaches felt too cumbersome or fragile for my use case.

The Solution

The best solution I found was to deploy a separate NGINX server dedicated to serving the ads.txt file. This approach:

• Keeps the Ghost configuration clean and focused.
• Provides a lightweight, scalable, and reusable solution.
• Ensures compliance with AdSense requirements.

I used Kubernetes to orchestrate the entire setup, creating a dedicated NGINX pod for ads.txt and integrating it with Ghost using an Ingress controller.

Step-by-Step Implementation

1. Define the ConfigMap for ads.txt

The ads.txt file content is stored in a Kubernetes ConfigMap for easy management. Here’s the configuration:

apiVersion: v1
kind: ConfigMap
metadata:
  name: ads-txt-config
  namespace: ghost
data:
  ads.txt: |
    XXXX

This ensures that the content of ads.txt is centralized and can be updated easily without redeploying the NGINX container.

2. Deploy NGINX as a Dedicated Service

I created a lightweight NGINX container that mounts the ConfigMap as a volume:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ads-server
  namespace: ghost
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ads-server
  template:
    metadata:
      labels:
        app: ads-server
    spec:
      containers:
      - name: nginx
        image: nginx:alpine
        volumeMounts:
        - name: ads-volume
          mountPath: /usr/share/nginx/html
      volumes:
      - name: ads-volume
        configMap:
          name: ads-txt-config

This deployment ensures that NGINX serves ads.txt directly from the mounted ConfigMap.

3. Create a Service for NGINX

To expose the NGINX pod, I created a Kubernetes Service:

apiVersion: v1
kind: Service
metadata:
  name: ads-service
  namespace: ghost
spec:
  selector:
    app: ads-server
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

The service makes the ads-server accessible within the cluster.

4. Update Ingress to Route /ads.txt Requests

Finally, I updated the Ingress configuration to ensure that requests to /ads.txt are routed to the ads-service:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: ghost-ingress
  namespace: ghost
  annotations:
    kubernetes.io/ingress.class: traefik
    traefik.ingress.kubernetes.io/router.entrypoints: websecure
spec:
  tls:
    - hosts:
        - example.com
      secretName: ghost-tls-secret
  rules:
    - host: example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: ghost
                port:
                  number: 80
          - path: /ads.txt
            pathType: Exact
            backend:
              service:
                name: ads-service
                port:
                  number: 80

This configuration ensures that:

• Requests to https://example.com/ads.txt are routed to the ads-service.
• All other requests are routed to the Ghost service.

Benefits of This Approach

• Clean Separation: Ghost handles its dynamic content, while NGINX takes care of static file serving.
• Scalability: Using Kubernetes, the NGINX service can be scaled independently.
• Simplicity: Leveraging ConfigMap ensures ads.txt content is easy to manage.

以上資訊用ChatGPT整理