VPS gratuit à vie : 4 cœurs ARM, 24 Go de RAM et 200 Go SSD (Oracle Cloud)

En bref

• Ce que tu obtiens : Un serveur VPS dédié gratuit à vie avec 4 OCPU (cœurs ARM Ampere A1), 24 Go de RAM, 200 Go de SSD NVMe et une IP publique IPv4 dédiée. • Le seul vrai piège : la région choisie à l'inscription. Si elle est saturée, tu tombes sur Out of host capacity. • La solution : bien choisir sa région, et un script qui réessaie tout seul si elle est pleine. • Coût réel : 0 € par mois, sans mauvaise surprise. • Temps de mise en place : Environ 10 minutes.

Quand un hébergeur cloud promet du « gratuit », on s'attend généralement à une machine minuscule : un cœur famélique, 512 Mo de RAM et une fin d'essai brutale au bout de douze mois.

Oracle Cloud propose une anomalie dans le paysage de l'infrastructure : le programme Always Free. Il permet d'allouer en permanence jusqu'à 4 OCPU ARM (Ampere A1) et 24 Go de mémoire vive, accompagnés de 200 Go de stockage disque SSD NVMe.

Pourtant, la quasi-totalité des développeurs qui tentent l'aventure se heurtent à un mur : l'erreur 500: Out of host capacity.

Ce guide explique d'où vient ce blocage, comment l'éviter, et comment obtenir ton serveur étape par étape, que tu sois sur macOS, Linux ou Windows.

Pourquoi l'offre Always Free d'Oracle écrase la concurrence

Comparons les offres gratuites des principaux acteurs du cloud :

| Fournisseur | CPU | RAM | Disque | Durée | |---|---|---|---|---| | Oracle Cloud | 4 OCPU ARM | 24 Go | 200 Go NVMe | À vie (Always Free) | | AWS (EC2) | 1 vCPU | 1 Go | 30 Go | 12 mois seulement | | Google Cloud | 1 vCPU partagé | 1 Go | 30 Go | À vie (très bridé) | | DigitalOcean / Hetzner | Aucun plan gratuit | - | - | Payant dès le 1er jour |

Avec 4 cœurs ARM64 et 24 Go de RAM, on dispose d'une puissance équivalente à une instance facturée entre 40 € et 70 € par mois chez les hébergeurs européens.

C'est la machine idéale pour faire tourner :

• Des agents IA autonomes (Hermes, OpenCode, Claude Code en tâche de fond)
• Des instances Docker, n8n, Supabase local ou PostgreSQL
• Un runner CI/CD GitHub Actions privé
• Tes API Node.js, Next.js, Python ou Go

Le seul vrai piège : la région

Presque tous les échecs viennent de la même erreur : 500: Out of host capacity. Elle ne veut pas dire que ton compte a un problème. Elle veut dire que la région choisie n'a plus de serveur ARM gratuit disponible à cet instant.

Deux règles d'Oracle rendent ce choix important :

1. Sur un compte gratuit, la Home Region choisie à l'inscription est définitive. Impossible d'en changer ensuite.
2. Les ressources Always Free n'existent que dans cette Home Region.

Comment bien choisir :

• Prends une région proche de toi (la latence compte pour un serveur que tu vas utiliser tous les jours).
• Évite si possible les régions les plus demandées de ta zone : ce sont elles qui sont saturées. Une région plus petite, dans le même pays ou un pays voisin, a souvent de la capacité immédiate.
• En France : prends Marseille (France Sud), pas Paris. Sur Paris, obtenir une machine ARM gratuite est en pratique impossible.

Ce qui m'est arrivé : j'ai d'abord créé mon compte à Paris, comme tout le monde. J'ai écrit un script qui retentait la création toutes les deux à trois minutes et je l'ai laissé tourner toute la nuit : pas une seule machine disponible, Out of host capacity à chaque essai. J'ai recréé un compte en choisissant Marseille, et le serveur 4 cœurs / 24 Go s'est libéré tout de suite, au premier essai. Si tu es en France, ne refais pas mon erreur : choisis Marseille dès l'inscription.

• La disponibilité change avec le temps : aucune région n'est garantie libre, aucune n'est définitivement bloquée.

Ton compte est déjà dans une région saturée ? Pas de panique. Le script de l'étape 4 demande d'abord la plus grosse machine gratuite (4 cœurs, 24 Go), puis plus petit (2 / 12, puis 1 / 6) si la région n'a pas de place, et recommence toutes les 85 secondes jusqu'à en obtenir une. Ça peut prendre quelques heures, mais ça finit par passer.

Avant de commencer

Il te faut :

• un ordinateur sous macOS, Linux ou Windows (Windows 10 ou 11 : utilise PowerShell, les commandes ssh et ssh-keygen y sont déjà installées) ;
• Python 3 (python3 --version sur macOS/Linux, py --version sur Windows) ;
• une carte bancaire pour la vérification d'identité ;
• une dizaine de minutes, plus le temps d'attente si ta région est pleine.

Tu préfères te faire guider ? Le bouton Envoyer à un agent en haut de page donne ce tuto à ton agent IA (Claude Code, Cursor, OpenCode). Il te pose les questions une par une (ton système, ton compte, ta région), puis te propose soit de lancer le script pour toi, soit de te le préparer pour que tu le lances toi-même.

Étape 1 : Créer son compte Oracle Cloud

1. Va sur Oracle Cloud Free Tier et clique sur Start for free.
2. Renseigne ton pays, ton nom et ton email.
3. Choisis ta Home Region. Si tu es en France : France Sud (Marseille), pas Paris. Sinon, suis les conseils ci-dessus. Ce choix est définitif : si tu te trompes, il faudra recréer un compte.
4. Ajoute ta carte bancaire. Oracle fait une autorisation temporaire pour vérifier que tu es une vraie personne, puis l'annule. Tant que tu restes dans les limites Always Free, rien n'est prélevé.
5. Attends l'email de confirmation (quelques minutes, parfois jusqu'à une heure), puis connecte-toi à la console.

Tu vérifies : tu vois la console Oracle Cloud, et ta région s'affiche en haut à droite.

Étape 2 : Créer une clé API

Cette clé permet au script de créer le serveur à ta place.

1. Dans la console, clique sur l'icône de profil en haut à droite, puis My profile (ou User settings).
2. En bas à gauche, dans Resources, clique sur API keys, puis Add API key.
3. Laisse Generate API key pair coché, clique sur Download private key (un fichier .pem se télécharge), puis sur Add.
4. Oracle affiche un aperçu de configuration (user, fingerprint, tenancy, region). Garde cette fenêtre ouverte ou copie le texte.

Tu vérifies : tu as un fichier .pem dans ton dossier Téléchargements et le bloc de configuration copié.

Étape 3 : Préparer ton ordinateur

1. Ranger la clé. Sur macOS ou Linux :

mkdir -p ~/.oci && chmod 700 ~/.oci
mv ~/Downloads/*.pem ~/.oci/oci_api_key.pem
chmod 600 ~/.oci/oci_api_key.pem

Sur Windows (PowerShell) :

New-Item -ItemType Directory -Force "$HOME\.oci"
Move-Item "$HOME\Downloads\*.pem" "$HOME\.oci\oci_api_key.pem"

2. Créer le fichier ~/.oci/config (Windows : C:\Users\ton_nom\.oci\config). Colle l'aperçu copié à l'étape 2 et ajoute la ligne key_file avec le chemin complet de ta clé :

[DEFAULT]
user=ocid1.user.oc1..xxxx
fingerprint=xx:xx:xx:...
tenancy=ocid1.tenancy.oc1..xxxx
region=ta-region          # recopiée telle quelle depuis l'aperçu
key_file=/chemin/complet/vers/.oci/oci_api_key.pem

3. Avoir une clé SSH. Vérifie si tu en as déjà une (ls ~/.ssh/*.pub). Sinon :

ssh-keygen -t ed25519 -C "oracle-vps"

Appuie sur Entrée aux questions pour garder les valeurs par défaut.

4. Installer le SDK Oracle et tester la connexion :

python3 -m pip install --user oci
python3 -c "import oci; c=oci.config.from_file(); print(oci.identity.IdentityClient(c).get_user(c['user']).data.name)"

Tu vérifies : la dernière commande affiche ton nom d'utilisateur Oracle. Si elle affiche une erreur NotAuthenticated, le fingerprint ou le chemin key_file est faux.

Étape 4 : Créer le réseau et le serveur

Un seul script fait tout : réseau virtuel, accès Internet, serveur Ubuntu 24.04 ARM, puis affichage de la commande de connexion. Il tente d'abord la config maximale (4 cœurs, 24 Go), puis 2 / 12, puis 1 / 6. Tu peux le relancer sans risque : il réutilise ce qui existe déjà.

Enregistre-le dans un fichier oracle_vps.py, puis lance python3 oracle_vps.py :

import os, sys, time
import oci

# La plus grosse config gratuite d'abord, puis plus petit si la région est pleine
SHAPES = [(4.0, 24.0), (2.0, 12.0), (1.0, 6.0)]
BOOT_GB = 200
NAME = "vps-arm-free"
RETRY_SECONDS = 85  # en dessous, Oracle répond 429 TooManyRequests

config = oci.config.from_file("~/.oci/config")
tenancy = config["tenancy"]
network = oci.core.VirtualNetworkClient(config)
compute = oci.core.ComputeClient(config)
identity = oci.identity.IdentityClient(config)
M = oci.core.models

# Clé SSH publique : ed25519 en priorité, sinon rsa
pub = next((os.path.expanduser(p) for p in ("~/.ssh/id_ed25519.pub", "~/.ssh/id_rsa.pub")
            if os.path.exists(os.path.expanduser(p))), None)
if not pub:
    sys.exit("Aucune clé SSH publique trouvée : lance d'abord ssh-keygen (étape 3).")
ssh_key = open(pub).read().strip()

# --- Réseau : VCN + passerelle Internet + route + sous-réseau public
vcns = network.list_vcns(tenancy).data
vcn = vcns[0] if vcns else network.create_vcn(M.CreateVcnDetails(
    cidr_block="10.0.0.0/16", display_name="VCN-ALWAYS-FREE", compartment_id=tenancy)).data
vcn = oci.wait_until(network, network.get_vcn(vcn.id), "lifecycle_state", "AVAILABLE").data

igws = network.list_internet_gateways(tenancy, vcn_id=vcn.id).data
igw = igws[0] if igws else network.create_internet_gateway(M.CreateInternetGatewayDetails(
    compartment_id=tenancy, vcn_id=vcn.id, is_enabled=True, display_name="IGW-ALWAYS-FREE")).data

rt = network.get_route_table(vcn.default_route_table_id).data
if not any(r.destination == "0.0.0.0/0" for r in rt.route_rules):
    network.update_route_table(rt.id, M.UpdateRouteTableDetails(route_rules=rt.route_rules + [
        M.RouteRule(destination="0.0.0.0/0", destination_type="CIDR_BLOCK", network_entity_id=igw.id)]))

subnets = [s for s in network.list_subnets(tenancy, vcn_id=vcn.id).data if not s.prohibit_public_ip_on_vnic]
subnet = subnets[0] if subnets else network.create_subnet(M.CreateSubnetDetails(
    compartment_id=tenancy, vcn_id=vcn.id, cidr_block="10.0.0.0/24", display_name="SUBNET-PUBLIC",
    route_table_id=vcn.default_route_table_id, security_list_ids=[vcn.default_security_list_id])).data
subnet = oci.wait_until(network, network.get_subnet(subnet.id), "lifecycle_state", "AVAILABLE").data

# --- Instance : réutilisée si elle existe, sinon création avec réessais si la région est pleine
existing = [i for i in compute.list_instances(tenancy, display_name=NAME).data
            if i.lifecycle_state not in ("TERMINATED", "TERMINATING")]
if existing:
    instance = existing[0]
else:
    images = compute.list_images(tenancy, operating_system="Canonical Ubuntu", operating_system_version="24.04",
                                 shape="VM.Standard.A1.Flex", sort_by="TIMECREATED", sort_order="DESC").data
    image_id = next(i.id for i in images if "Minimal" not in i.display_name)
    ads = [a.name for a in identity.list_availability_domains(tenancy).data]
    details = lambda ad, ocpus, mem: M.LaunchInstanceDetails(
        display_name=NAME, compartment_id=tenancy, availability_domain=ad, shape="VM.Standard.A1.Flex",
        shape_config=M.LaunchInstanceShapeConfigDetails(ocpus=ocpus, memory_in_gbs=mem),
        source_details=M.InstanceSourceViaImageDetails(image_id=image_id, boot_volume_size_in_gbs=BOOT_GB),
        create_vnic_details=M.CreateVnicDetails(subnet_id=subnet.id, assign_public_ip=True),
        metadata={"ssh_authorized_keys": ssh_key})
    instance, attempt = None, 0
    while instance is None:
        for ocpus, mem in SHAPES:
            for ad in ads:
                attempt += 1
                try:
                    instance = compute.launch_instance(details(ad, ocpus, mem)).data
                    print(f"Obtenu : {int(ocpus)} OCPU / {int(mem)} Go")
                    break
                except oci.exceptions.ServiceError as e:
                    if e.status == 500 and "capacity" in e.message.lower():
                        print(f"[{attempt}] {int(ocpus)} OCPU / {int(mem)} Go : région pleine")
                    elif e.status == 429:
                        print(f"[{attempt}] trop de requêtes, pause")
                    else:
                        raise
            if instance is not None:
                break
        if instance is None:
            time.sleep(RETRY_SECONDS)

print("Instance créée, démarrage en cours...")
instance = oci.wait_until(compute, compute.get_instance(instance.id), "lifecycle_state", "RUNNING",
                          max_wait_seconds=900).data

# --- IP publique
vnic_id = compute.list_vnic_attachments(tenancy, instance_id=instance.id).data[0].vnic_id
ip = network.get_vnic(vnic_id).data.public_ip
key = pub[:-4]
print(f"ssh -i {key} ubuntu@{ip}")

Ce que tu vas voir :

• Si ta région a de la place : en une à deux minutes, le script affiche Obtenu : 4 OCPU / 24 Go puis une ligne ssh -i ... ubuntu@ton_ip.
• Si ta région est pleine : des lignes région pleine, nouvel essai dans 85 s. C'est normal. Laisse tourner (tu peux fermer le capot si ton ordinateur ne se met pas en veille, ou le lancer sur une machine allumée en permanence). Si tu ne veux que la machine complète, remplace la liste par SHAPES = [(4.0, 24.0)]. Si tu as obtenu une machine plus petite, tu pourras l'agrandir plus tard depuis la console quand de la place se libère.

Étape 5 : Se connecter et vérifier

Copie la commande affichée par le script :

ssh -i ~/.ssh/id_ed25519 ubuntu@ton_ip_publique

À la question Are you sure you want to continue connecting, réponds yes. Puis vérifie ce que tu as obtenu :

uname -m && nproc && free -h && df -h /

Tu vérifies : aarch64, 4, environ 23 Gi de mémoire et environ 190 Go de disque. Ton serveur est prêt.

Garder ta machine active

Oracle peut arrêter une instance Always Free considérée comme inutilisée : quand, sur 7 jours, le processeur, le réseau et la mémoire restent tous très bas (moins de 20 %). La solution saine est simple : fais-y tourner de vrais services (Docker, base de données, bot, runner CI, agent IA). Une machine qui sert ne risque rien.

En résumé

1. Choisis ta Home Region avec soin : en France, Marseille ; ailleurs, une région proche mais pas la plus demandée.
2. Crée ta clé API et ton fichier ~/.oci/config.
3. Lance le script : il vise 4 cœurs / 24 Go, descend si besoin, et réessaie seul si la région est pleine.
4. Connecte-toi en SSH.

Si tu veux être guidé pas à pas, utilise le bouton Envoyer à un agent en haut de page.