thomas@hammoudi:~/dev$

Site des apps

Héberger gratuitement un site de 15 000 pages sur Cloudflare

15 000 pages, des comptes, un scanner et des collectes de nuit : mon site tient dans les offres gratuites de Cloudflare (hébergeur) et GitHub, grâce à des contrôles qui bloquent la mise en ligne avant chaque limite.

en service · 15 000 pages hébergées sans payer, chaque limite mesurée · mis à jour en

Avant
Une limite gratuite franchie sans prévenir, et Cloudflare ignorait toutes les redirections du site.
Maintenant
15 000 pages en ligne sans payer : chaque limite est mesurée, et la mise en ligne bloquée avant.

Utile si vous voulez héberger un gros site sans payer, ou vous butez sur les limites d'une offre gratuite.

En 3 étapes

  1. Je liste les plafonds de l'offre gratuite avant d'écrire une ligne, et je chiffre chaque requête envoyée à la base de données.
  2. À chaque mise en ligne du site, des contrôles comptent les fichiers et les lectures dans la base, et alertent avant la limite.
  3. Si un plafond approche trop, la mise en ligne est bloquée et je tranche : passer à une offre payante n'est jamais un réflexe.
terminal~/Développement
$ node scripts/check/limites.mjs
limites : scan-index 2.23 Mo en 16 tranches (17 fichiers)
limites : miroir des couvertures 12059 fichiers (60 % du plafond Pages)
limites OK : 15704 fichiers (79 % du plafond Pages), aucun fichier > 25 Mio
$ site-sous-les-plafonds-gratuits --schema7 étapes · 1 fait maison

A · Chaque mise en ligne

01

Moi

je modifie le site

une modification

02

La construction

marquée par la version du code

GitHub ActionsAstroNode.js

fichiers comptés

03fait maison

Les contrôles

alerte à 80 %, blocage à 95 %

retour en 01 : alerte : je tranche

mise en ligne

04

Le site

plus de 15 000 pages en ligne

Cloudflare Pages

B · Quand un visiteur utilise le site

05

Un visiteur

utilise un compte ou le scanner

une demande

06

Les fonctions

nombre de requêtes fixe

par clé : La base

Cloudflare Workers

ce qu'il demande

07

La réponse

sans dépasser le plafond

Les données

La base

4,8 % du plafond de lecture au plus

lu et écrit par 06

Cloudflare D1

alerte : je tranche

par clé

À côté

Le second projet

couvertures converties une fois

Cloudflare PagesWebP

Aucune offre payante : chaque plafond a dicté un choix.

  • fait maison
  • outil du marché, source ou résultat
  • une personne
  • les données

le détail, étape par étape

Pourquoi je l'ai fait

Sur mon site des apps, il y a plus de 15 000 pages, des comptes, un scanner et des collectes de nuit. Et il ne devait rien me coûter à héberger. Les offres gratuites de Cloudflare et de GitHub le permettent, mais chacune a ses plafonds, et un plafond franchi peut tout casser. En septembre 2026, le fichier des redirections a dépassé de 33 règles la limite de 2 000 : Cloudflare l’a ignoré en entier. Charmant.

Ce que ça fait, concrètement

Le site tourne dans les offres gratuites, et chaque plafond est mesuré :

  • Base de données (Cloudflare D1) : 5 millions de lignes lues et 100 000 écrites par jour. De fin octobre à début novembre 2026, sur 14 jours, le site en a lu au plus 4,8 % et écrit au plus 15,5 %.
  • Hébergement des pages : 20 000 fichiers par mise en ligne. La construction de fin octobre 2026 en comptait 15 704.
  • Fonctions (le code qui répond à chaque visite) : 50 sous-requêtes, c’est-à-dire des appels vers la base ou d’autres services, et environ 10 millisecondes de calcul par appel.
  • GitHub Actions : 2 000 minutes par mois pour toutes les constructions et toutes les collectes.

À chaque construction, des contrôles relèvent ces compteurs : ils alertent avant un plafond, et bloquent la mise en ligne s’il est trop proche.

Comment ça marche, en détail

Fabrication : 15 des 18 scripts de contrôle du dépôt tournent à chaque construction

L’idée, c’est de traiter chaque limite comme une règle de conception. Je lis peu dans la base, je fais un nombre fixe de requêtes par appel, je ne renvoie vers Cloudflare que les fichiers qui changent, et je place chaque donnée dans des fichiers ou dans la base selon le plafond qui pèse le plus. Des contrôles lancés à chaque construction le vérifient.

Lire peu : sur D1, on compte les lignes parcourues, pas les lignes rendues

Fin septembre 2026, Cloudflare m’a prévenu que le site avait atteint 90 % du plafond du jour. En cause : une seule requête de l’agenda, mal écrite, qui parcourait plus d’un million de lignes à chaque passage. Après correction, une construction complète lit environ 9 000 lignes au lieu de 36 000. Depuis, chaque script compte ses lignes et s’arrête en erreur bien avant le plafond.

Un nombre fixe de requêtes : la liste passe en un seul paramètre, un test refuse toute requête dans une boucle

Une fonction gratuite a droit à 50 requêtes vers la base par appel. Chaque appel du compte coûte donc le même nombre de requêtes, qu’il porte sur un livre ou sur cinq cents : la liste passe en un seul paramètre. Un test automatique refuse toute requête placée dans une boucle.

Ne renvoyer que ce qui change : une construction marquée par la version du code, pas par l’heure

Deux constructions du même code donnent des pages identiques : seuls les fichiers dont les données ont changé repartent vers Cloudflare. Avant, les 12 700 pages de l’époque repartaient toutes, cinq fois par jour.

Fichiers ou base, selon le plafond : 16 fichiers pour le scanner, couvertures en WebP, articles par une fonction

Les livres que lit le scanner ne sont pas dans la base : ils tiennent dans 16 fichiers statiques, lus sans toucher D1. À l’inverse, pour rester sous les 20 000 fichiers, les couvertures, converties une fois en WebP, sont servies par un second projet, et les articles de la veille photo par une fonction. La place reste aux fiches fabriquées en série.

Des contrôles lancés à chaque construction, pas seulement écrits : 15 scripts sur 18

En novembre 2026, 15 des 18 scripts de contrôle du dépôt tournent à chaque construction : plafonds, lignes lues, liens internes, données structurées, affichage sur téléphone.

Le rôle de chaque pièce

Les 7 étapes du schéma, une par une
  1. Moi Je modifie le site. Quand un plafond approche, je tranche : passer à une offre payante reste ma décision, jamais un réflexe.
  2. La constructionGitHub Actions · Astro · Node.js Deux constructions du même code donnent des pages identiques : seuls les fichiers dont les données ont changé repartent vers Cloudflare.
  3. Les contrôlesfait maison À chaque construction, ils comptent les fichiers, les lignes lues et écrites, la taille des index. En novembre 2026, 15 scripts sur 18 tournent à chaque construction.
  4. Le siteCloudflare Pages Les pages sont servies par Cloudflare Pages, sous la limite de fichiers par mise en ligne.
  5. Un visiteur Un visiteur ouvre son compte, scanne un livre ou envoie un formulaire.
  6. Les fonctionsCloudflare Workers Chaque appel coûte le même nombre de requêtes vers la base, que la liste porte sur un livre ou cinq cents. Un test refuse toute requête dans une boucle.
  7. La réponse Le visiteur reçoit sa réponse ; la base n'est lue que par clé, au plus 4,8 % du plafond de lecture par jour sur 14 jours.

# mémoires

  • La baseCloudflare D1 La mémoire des collectes et des comptes. Ce qui est décompté, ce sont les lignes parcourues, pas les lignes rendues.

# à côté

  • Le second projetCloudflare Pages · WebP Pour rester sous les 20 000 fichiers, les couvertures, converties une fois en WebP, sont servies par un second projet.

Ce que vous pouvez reprendre chez vous

Face à un service gratuit, quel qu’il soit : listez ses plafonds avant d’écrire une ligne, chiffrez chaque requête avant de la poser, lisez le compteur après, et bloquez la mise en ligne avant la limite. Le code, je le garde.

Ce que j'en retiens

Un plafond gratuit, pour moi, c’est une règle du jeu. La plupart de mes choix techniques sur ce site en viennent, et le site en est plus rapide. La leçon de septembre 2026 : une requête qui rend dix lignes peut en parcourir un million. Depuis, je regarde aussi le compteur.

J'en parle ici

tous les projets