L’annonce a été faite dans le cadre du sommet franco-allemand « Summit on European Digital Sovereignty – Shaping Europe’s digital future. Together ». Les deux entreprises y voient un levier essentiel pour rendre l’intelligence artificielle plus accessible et réellement souveraine en Europe.

Elles rappellent que, malgré un intérêt croissant pour l’IA, l’adoption industrielle reste largement freinée par les coûts de calcul. Les systèmes actuels de SpiNNcloud permettent déjà de réduire certains coûts jusqu’à 17 fois. La prochaine architecture, SpiNNext, devrait pousser encore plus loin ces gains d’efficacité, avec des économies potentielles allant jusqu’à un facteur 80. Une avancée qui pourrait changer la dynamique d’industrialisation de l’IA sur le continent.

Une coopération franco-allemande pour une infrastructure IA souveraine

Les deux partenaires considèrent leur collaboration comme un élément structurant d’un axe franco-allemand dédié aux infrastructures d’IA. Ils soulignent qu’une concurrence durable face aux géants internationaux ne sera possible qu’en renforçant la coopération entre acteurs européens. Leur ambition dépasse d’ailleurs leur seule collaboration : ils souhaitent associer d’autres PME innovantes du continent pour constituer un réseau d’expertise capable de fournir des briques essentielles du numérique, sans dépendance extérieure.

Clever Cloud exploite une plateforme cloud européenne pour l’hébergement, l’automatisation, les bases de données et l’orchestration. Toute la technologie est développée en interne et opérée en Europe. L’entreprise emploie une centaine de personnes et accompagne des clients dans plus de 120 pays.
SpiNNcloud, de son côté, développe des architectures de calcul inspirées du fonctionnement du cerveau humain, destinées au calcul haute performance et aux applications d’intelligence artificielle. Ses systèmes reposent aujourd’hui sur l’architecture SpiNNaker2, tandis que SpiNNext est déjà en développement.

La coopération est entrée dans une phase opérationnelle. Les premiers systèmes SpiNNcloud sont en cours d’intégration dans l’infrastructure de Clever Cloud, et des tests techniques sont en cours. Deux axes de travail sont en développement : l’exploitation directe de la performance des systèmes pour les calculs intensifs, et une couche commune de « Token as a Service », permettant aux entreprises d’utiliser des services d’IA – modèles de langage ou autres algorithmes – sur la base d’une consommation réelle, avec des coûts et une dépense énergétique nettement réduits. Les équipes ont aligné leur feuille de route sur l’intégration, la sécurité et l’exploitation.

En s’appuyant sur des technologies européennes, tant matériel que logiciel, les deux entreprises souhaitent contribuer à l’émergence d’une infrastructure d’IA vraiment indépendante. À la suite du sommet, elles entendent poursuivre les échanges avec les autorités françaises, allemandes et européennes pour partager leur retour d’expérience sur les infrastructures, l’efficacité énergétique et la souveraineté numérique. L’événement entre le président Emmanuel Macron et le chancelier Friedrich Merz sert d’ailleurs de cadre à de nombreux échanges avec les délégations présentes.

Quentin Adam, CEO de Clever Cloud, déclare : « Nous voulons une Europe qui développe ses propres technologies et maîtrise son avenir numérique. Avec SpiNNcloud, nous démontrons que l’industrie européenne a non seulement le savoir-faire, mais aussi la volonté de répondre aux défis majeurs de l’IA : coûts, consommation énergétique, souveraineté. Cette collaboration montre qu’une Europe qui coopère peut concevoir des infrastructures performantes, efficaces et réellement indépendantes. »

Hector Gonzalez, CEO de SpiNNcloud, ajoute : « Avec Clever Cloud, nous avons trouvé un partenaire idéal pour mettre l’efficacité énergétique unique de nos systèmes inspirés du cerveau au service des usages industriels. Cette coopération franco-allemande prouve que l’Europe dispose des briques technologiques nécessaires pour bâtir des solutions compétitives et souveraines. »

À propos de SpiNNcloud

SpiNNcloud réinvente l’infrastructure IA grâce à une architecture de calcul inspirée du cerveau, pensée pour réduire drastiquement la consommation énergétique tout en maintenant un haut niveau de performance. Son approche événementielle, dans laquelle les calculs ne se déclenchent que lorsqu’ils sont réellement nécessaires, ouvre de nouvelles marges d’efficacité. L’entreprise fournit des systèmes complets à des centres de recherche et des entreprises dans le monde entier.

Vous souhaitez en savoir plus sur ce projet ?

N'hésitez pas à nous contacter

Contactez-nous

Les fournisseurs de services IA se multiplient. Chacun y va de son nouveau modèle, plus rapide, plus convaincant pour créer des applications, capable de "réflexion". Mais de plus en plus, les utilisateurs cherchent non pas à obtenir de réponses génériques plus ou moins efficaces et pertinentes. Ils veulent disposer d'assistants qui peuvent aller récupérer du contexte depuis différents services afin de les faire travailler ensemble.

MCP: le Function Calling et au-delà

Depuis quelque temps déjà, les modèles se sont dotés d'une capacité dite de Function Calling. Lorsqu'un type de phrase particulier est repéré, il peut être utilisé pour appeler une fonction et lui fournir des paramètres afin de récupérer une réponse issue d'un service tiers. Mais comme souvent, cela s'est fait dans les premiers temps avec une approche différente d'un fournisseur à l'autre, d'un outil de déploiement à l'autre. Ainsi est né MCP : Model Context Protocol.

Présenté par Anthropic fin novembre, MCP se donne pour but de standardiser la manière de fournir du contexte aux grands modèles de langage (LLMs). Il prend la forme d'un serveur, dit serveur MCP, et un client qui peut exposer des fonctions, des prompts, mais également des ressources telles que du texte, des logs, des images, etc. Et d'un serveur qui peut lister tous ces éléments afin de les utiliser. Le protocole, ouvert et actuellement en pleine évolution, repose sur JSON-RPC 2.0 et deux modes de "transport" : stdio et SSE (Server-Sent Events), mais d'autres peuvent être exploités. Si vous voulez en savoir plus, les spécifications techniques sont détaillées par ici.

Il existe différentes implémentations officielles, pour Kotlin, Python, TypeScript, puis une myriade des solutions officieuses. On trouve d'ailleurs déjà de nombreuses listes de clients/serveurs qui vont de la capacité à lire des fichiers locaux à la lecture de bases de données ou la récupération d'information depuis un compte GitHub par exemple. Outre l'intégration aux clients Desktop de Claude (le service de chat d'Anthropic), plusieurs IDE et extensions se mettent à MCP: Cline, Continue, Zed, etc.

En pratique, il n'est pas très complexe de créer un serveur MCP, d'autant que les SDK peuvent vous y aider et que les guides se multiplient. Mais comment les exposer à une multitude de modèles, les intégrer à vos outils ensuite ? C'est là que les choses peuvent se compliquer.

Otoroshi simplifie l'accès au Function calling et à MCP

Ainsi, dès décembre nous avons commencé à travailler avec l'équipe de Cloud APIM afin de simplifier l'usage de ce protocole au sein d'Otoroshi with LLM, que nous proposons sous la forme d'un add-on qui se déploie en quelques clics. Il supportait déjà nativement le Function Calling, permettant à n'importe quel modèle d'être enrichi par des fonctions écrites en Web Assembly (WASM, via Extism) ou en JavaScript. C'était l'occasion d'aller plus loin.

Ainsi, la nouvelle version déployée sur Clever Cloud gère désormais:

• MCP Endpoint : pour exposer des fonctions aux clients MCP
• MCP Connectors : pour ajouter des fonctions depuis un serveur MCP

Les serveurs MCP créés par Otoroshi peuvent communiquer avec des clients directement via SSE, mais également des requêtes HTTP ou des WebSocket. Leur création ne prend que quelques minutes. Si votre client ne supporte que stdio, vous pouvez utiliser le proxy développé par l'équipe de Cloud APIM qui assurera de communication avec le serveur.

Nous en avons profité pour ajouter le support de DeepSeek comme fournisseur et le support des fonctions sous la forme d'appel HTTP. Ainsi, Otoroshi peut exploiter notre FaaS, actuellement en alpha privée, avec différents modèles d'IA.

Et en pratique ?

Envie d'en savoir plus ? Rendez-vous à 13h sur notre chaîne Twitch ! Nous organisons une démonstration en direct. Vous pourrez ainsi découvrir comment configurer et utiliser Otoroshi with LLM pour créer vos propres clients/serveurs MCP en quelques minutes !

N'hésitez pas également à venir à notre rencontre au Paris Open Source AI Summit ce mercredi 22 janvier, plusieurs membres de notre équipe seront sur place.

Si l'IA fait parler d'elle ces derniers temps, c'est notamment au travers des larges modèles de langages (LLMs) qui nécessitent une puissance de calcul conséquente pour leur entrainement ou leur exécution. Ainsi, il est courant de voir les développeurs y recourir à travers des API clés en main, comme nous l'avions fait dans un précédent article. Mais cela change grâce à des modèles et outils plus ouverts et efficaces, que vous pouvez très facilement déployer sur Clever Cloud.

En effet, si notre plateforme a été pensée pour certains usages, nous avons toujours accordé une grande importance à sa flexibilité et à la liberté laissée à nos clients. Ils peuvent ainsi aisément l'exploiter pour attaquer de nouveaux marchés, avec très peu de travail d'adaptation.

Pour le vérifier, nous avons récemment tenté de déployer des modèles d'IA open source tels que ceux dérivés de LLaMA et Mistral. Ils ont pour particularité d'exister dans des versions allégées, ne nécessitant pas forcément de GPU pour fonctionner. Ainsi, il est possible de les héberger comme de simples applications Clever Cloud, tant qu'assez de mémoire leur est attribuée.

Let's ollama (avec une interface web) !

Pour cela, nous avons choisi d'utiliser ollama, un projet sous licence MIT qui permet de télécharger des modèles disponibles depuis un registre ou même les vôtres. Il prend la forme d'un serveur qui communique via une API, très simple à héberger sur nos infrastructures.

• Créer un compte Clever Cloud (et obtenir 20 euros de crédits)

Pour commencer, vous devrez disposer d'un compte Clever Cloud. Vous pouvez créer l'application et suivre les étapes suivantes en utilisant notre interface web, la Console, mais aussi à travers notre CLI open source : Clever Tools. C'est ce que nous ferons ci-dessous.

Nous partirons ainsi du principe que vous disposez d’une machine avec git et Node.js dans une version récente. Si vous n’avez pas encore installé les Clever Tools sur votre système, tapez (avec les droits administrateur de votre système ou sudo si nécessaire) :

npm i -g clever-tools
clever login

Une fois connecté, vous pourrez vérifier que tout s’est bien passé avec la commande suivante :

clever profile

Ensuite, nous créons une application Clever Cloud avec Node.js. Elle installera ollama pour télécharger et exécuter nos modèles, en lui ajoutant avec une interface web (chatbot-ollama, également sous licence MIT) qui nous permettra d'interroger le serveur depuis n'importe quel navigateur, exécuté depuis un ordinateur ou même un simple smartphone.

Cette solution a également l'intérêt de stocker les conversations localement, dans le navigateur. Elle ne nécessite donc pas de base de données, mais propose une fonction d'import/export. On peut également choisir entre différents modèles, régler certains de leurs paramètres, configurer des instructions système, différents prompts, etc.

mkdir myollama && cd myollama
git init
curl -L https://github.com/ivanfioravanti/chatbot-ollama/archive/refs/heads/main.tar.gz | tar -xz --strip-components=1

clever create -t node myollama && clever scale --flavor L
clever env set CC_POST_BUILD_HOOK "npx next telemetry disable && npm run build"
clever env set CC_PRE_BUILD_HOOK "./ollama_setup.sh"
clever env set CC_PRE_RUN_HOOK "./ollama_start.sh"

echo "orca-mini" > models.list
echo "mistral" >> models.list
echo "codellama" >> models.list

Le code ci-dessus créé l'application. Nous y ajoutons un fichier qui contiendra la liste des modèles à récupérer lors de son initialisation. Nous optons pour une instance L, la taille minimale pour charger de tels modèles en mémoire. On déclare ensuite plusieurs variables d'environnement pour lancer des scripts afin d'installer ollama, démarrer le serveur et désactiver la télémétrie du framework Next.js, utilisé pour construire l'interface web après l'installation des dépendances.

Ajoutons quelques scripts

Notre application est presque prête. Il nous reste en effet à créer deux fichiers, exécutables :

touch ollama_setup.sh && chmod +x ollama_setup.sh
touch ollama_start.sh && chmod +x ollama_start.sh

ollama_setup.sh télécharge le binaire d'ollama puis les modèles de notre liste. Ouvrez-le avec l'éditeur de votre choix et placez-y le contenu suivant :

#!/bin/bash

# We define the folder (in $PATH), where the ollama binary will be placed
BIN_DIR=${HOME}/.local/bin
mkdir -p ${BIN_DIR} 

ollama_start() {
    echo "Downloading and launching ollama..."
    curl -Ls https://ollama.ai/download/ollama-linux-amd64 -o ${BIN_DIR}/ollama
    chmod +x ${BIN_DIR}/ollama
    ollama serve &> /dev/null &
    echo -e "Finished: \033[32m✔\033[0m\n"
}

get_models() {
    MODELS_FILE="models.list"
    MODELS_DEFAULT="orca-mini"

    # We check if the models file exists
    if [ ! -f ${MODELS_FILE} ]; then
        echo "File ${MODELS_FILE} not found, ${MODELS_DEFAULT} used by default."
        echo ${MODELS_DEFAULT} > ${MODELS_FILE}
    fi

    # Loop through each line and pull model
    while IFS= read -r line; do
        echo "Pulling ${line} model..."
        ollama pull "${line}" > /dev/null 2>&1
        echo -e "Finished: \033[32m✔\033[0m\n"

    done < ${MODELS_FILE}
}

# We start ollama, and wait for it to respond
ollama_start
if [ $? -ne 0 ]; then
    echo -e "\nError during ollama setup."
    exit 1
fi

count=0
MAX_TIME=10

while ! pgrep -x "ollama" > /dev/null; do
    if [ ${count} -lt ${MAX_TIME} ]; then
        sleep 1
        count=$((count+1))
    else
        echo "Application 'ollama' did not launch within 10 seconds."
        exit 1
    fi
done

get_models
if [ $? -ne 0 ]; then
    echo -e "\nError during models downloading."
    exit 1
fi

Ce code peut paraître un peu long, mais c'est notamment parce que nous l'avons rendu modulaire, en n'écrivant dans les logs que les étapes réussies ou les éventuelles erreurs.

ollama_start.sh détecte si le serveur ollama est déjà présent avant de démarrer l'interface web. Si ce n'est pas le cas, on le lance en tâche de fond (nous verrons plus bas pourquoi).

Ouvrez-le avec l'éditeur de votre choix et placez-y le contenu suivant :

if ! pgrep -f "ollama" > /dev/null; then
    # If 'ollama' is not running, start it in the background
    ollama serve &
    echo "Application 'ollama' started."
else
    # If 'ollama' is already running
    echo "'ollama' application is already running."
fi

Une fois ces deux fichiers créés, on peut déployer notre application :

git add . && git commit -m "Init application"
clever deploy
clever domain

Vous verrez alors le domaine pour accéder à votre application (que vous pouvez personnaliser).

Cache et (re)démarrage rapide

Utiliser Clever Cloud, ce n'est pas simplement déployer facilement une telle application, disposer de logs et de monitoring, pouvoir changer instantanément son scaling horizontal et/ou vertical. C'est aussi pouvoir en faire une image prête à redéployer très rapidement.

En effet, toute application que nous hébergeons est stockée sous la forme d'une archive constituée juste avant l'installation des dépendances. Elle peut ainsi être arrêtée et de rédémarrée sous cette forme, ce qui nous permet de ne pas retélécharger les modèles à chaque fois. Pour cela, il suffit d'indiquer les dossiers à ajouter à l'archive :

clever env set CC_OVERRIDE_BUILDCACHE "/:../.ollama/:../.local/bin/"
clever restart --without-cache --follow

L'application redémarrera, mais prendra cette fois les l'interface web construite, ollama et les modèles dans son cache, les étapes CC_PRE_BUILD_HOOK et CC_PRE_BUILD_HOOK n'étant pas exécutées. C'est notamment pour cela que nous devons nous assurer que l'on démarre bien le serveur ollama avec CC_PRE_RUN_HOOK, mais que l'on vérifie que cela n'a pas déjà été fait lors d'un démarrage classique; où il est utilisé pour télécharger les modèles avant de les exécuter.

Dès que cette étape est terminée, vous pouvez arrêter l'application et la redémarrer lorsque vous voulez, cela sera désormais bien plus rapide. Et vous ne serez facturé que le temps de son usage, à la seconde. Si vous voulez modifier la liste des modèles à utiliser, faites le dans le fichier prévu à cet effet, un git push suffira à reconstituer le nouveau cache.

# Stop/Restart the application
clever stop
clever restart

# After a modification in models.list, git push to recreate the cache
git add models.list && git commit -m "New models" 
clever deploy

Vous retrouverez le fichiers nécessaires à ce projet dans ce dépôt GitHub, avec les variables d'environnement prêtes à importer (clever env import < .env).

Et si jamais vous voulez aller plus loin en déployant d'autres modèles et outils pour vos applications, qui nécessitent plus de puissance et/ou du GPU, faites-le nous savoir !

Depuis l'année dernière, OpenAI est sur le devant de la scène avec ses larges modèles de langage (LLM), notamment GPT-3.5 et GPT-4, accessibles via son service ChatGPT. Mais ils sont également proposés sous la forme d'une API, que vous pouvez utiliser dans vos applications. Voici un exemple de la manière d'en profiter sur Clever Cloud.

Nous nous baserons sur le projet open source chat-wtf, créé par Unconventional Coding qui a détaillé les différentes étapes de sa conception dans une série de vidéos. Il se repose principalement sur le langage PHP et un stockage des données via des sessions, SQLite ou MySQL, au choix de l'utilisateur.

Un ChatGPT open source, utilisable à la demande

Il nécessite d'utiliser l'API d'OpenAI, mais vous pouvez lui préférer des modèles compatibles si vous êtes plus aventureux. Le fichier de paramètres permet également de préciser un « message système ». Ainsi, vous pouvez fournir à l'IA des informations sur vous ou vos attentes, qu'elle devra prendre en compte dans ses réponses.

Cette application PHP n'a pas été développée d'une manière spécifique pour Clever Cloud, mais vous pouvez l'héberger dans nos infrastructures en quelques minutes, la configurer selon vos besoins, l'arrêter et le démarrer à la demande. On vous explique comment faire.

• Créer un compte Clever Cloud (et obtenir 20 euros de crédits)

Pour commencer, vous devrez disposer d'un compte Clever Cloud, ainsi que d'une clé d'API OpenAI. Vous pouvez créer l'application et suivre ce guide en utilisant notre interface web, la Console, mais aussi à travers notre CLI open source : Clever Tools. C'est ce que nous ferons ci-dessous.

Récupération du code et configuration

Nous partirons ainsi du principe que vous disposez d’une machine avec git et Node.js dans une version récente. Si vous n’avez pas encore installé les Clever Tools sur votre système, tapez (avec les droits administrateur de votre système ou sudo si nécessaire) :

npm i -g clever-tools
clever login

Une fois connecté, vous pourrez vérifier que tout s’est bien passé avec la commande suivante :

clever profile

Ensuite, vous pourrez créer un fork de chat-wtf pouvant être déployé sur Clever Cloud depuis votre compte GitHub. Dans cet exemple, nous allons cloner le dépôt localement et y créer une application Clever Cloud. Un remote nécessaire à son déploiement sera automatiquement ajouté :

git clone https://github.com/unconv/chat-wtf.git && cd chat-wtf
clever create -t php chat-wtf

Ainsi, vous disposez d'une copie locale de la dernière version de l'application chat-wtf, que vous pouvez configurer selon votre besoin. Renommez le fichier settings.sample.php en settings.php. Nous allons opérer des modifications mineures pour commencer.

Placez-y le contenu suivant afin d'utiliser des variables d'environnement :

<?php
return [
    "api_key" => getenv("OPENAI_API_KEY"),
    "system_message" => getenv("SYSTEM_MESSAGE"),
    "model" => "gpt-3.5-turbo",
    "base_uri" => "",
    "storage_type" => "session",
];

Éditez le fichier .gitignore afin d'en retirer settings.php pour qu'il puisse être déployé avec votre application. Celle-ci étant configurée, il ne reste plus qu'à indiquer les variables d'environnement nécessaires à son bon fonctionnement, puis à la déployer. Notez que PHP 8.x est requis. Nous utiliserons la branche 8.2 :

clever env set CC_PHP_VERSION "8.2"
clever env set OPENAI_API_KEY "Votre clé d'API OpenAI"
clever env set SYSTEM_MESSAGE "Votre message système"
git add . && git commit -m "First deploy"
clever deploy && clever open

Une fois les variables d'environnement ajoutées, nous effectuons un simple Git Push. L'application est alors déployée sur Clever Cloud, une archive est créée afin de faciliter son redéploiement, puis elle est ouverte dans votre navigateur si tout s'est bien passé :

Comme pour toute application hébergée au sein de notre service, vous pouvez lui attribuer simplement un domaine qui bénéficiera de notre load balancer Sōzu et d'un certificat Let's Encrypt, connaître son statut et son activité, l'arrêter ou la redémarrer.

Vous disposez dans la Console de métriques et d'un accès à un dashboard Grafana afin de suivre son état. Vous pouvez également adapter la taille de l' instance ou activer l'auto-scalabiilté pour répondre à différents niveaux de charge :

clever console

clever domain
clever domain add domain.tld

clever status
clever activity

clever scale --min-instances 1 --max-instances 4 --min-flavor pico --max-flavor M
clever scale --instances 1 --flavor pico

clever restart
clever stop

Ajoutons une base de données à notre instance chat-wtf

Comme indiqué précédemment, ce projet peut stocker ses données au sein de sessions PHP, mais également via SQLite ou MySQL. Dans cet exemple, nous opterons pour la dernière solution afin de vous montrer comment procéder, là aussi de manière très simple.

Tout d'abord créons une base de données (BDD) MySQL au sein de votre compte Clever Cloud en la liant directement à votre application. Par défaut il s'agit d'une instance DEV, partagée et gratuite, mais vous pouvez demander un plan de taille supérieure si vous le désirez :

clever addon create mysql-addon chat-wtf-mysql --link chat-wtf

Ce « lien » permet d'injecter directement les paramètres de connexion dans l'application via des variables d'environnement. Elles sont visibles dans la Console ou via les Clever Tools :

clever env

Ainsi, il suffit de modifier le fichier settings.php comme suit pour l'utiliser :

    "storage_type" => "sql",
    "db" => [
        "dsn" => "mysql:host=" . getenv('MYSQL_ADDON_HOST') . ";
                    port=" . getenv('MYSQL_ADDON_PORT') . ";
                    dbname=" . getenv('MYSQL_ADDON_DB'),
        "username" => getenv('MYSQL_ADDON_USER'),
        "password" => getenv('MYSQL_ADDON_PASSWORD'),
    ],

Rendez-vous ensuite dans le dashboard de cette base MySQL, accessible via la Console. Vous y trouverez un lien vers son interface PHPMyAdmin. En cliquant sur le nom de la base de données dans le menu de gauche vous trouverez la fonction d'import. Elle vous permettra d'initier la structure de la BDD en y important le fichier mysql.sql qui se trouve dans le dossier db du dépôt. Indiquez son emplacement, cliquez sur « Importer ». Ce sera fait :

Vous pouvez également le faire via un script Shell qui vérifie si la base de données est vide, et importe les données par défaut si nécessaire. Créez un fichier nommé init.sh contenant ce code :

SSE="SELECT COUNT(*) FROM information_schema.tables WHERE table_schema='$MYSQL_ADDON_DB';"
PARAMS="-u $MYSQL_ADDON_USER -h $MYSQL_ADDON_HOST -P $MYSQL_ADDON_PORT -D $MYSQL_ADDON_DB"

TABLE_COUNT=$(MYSQL_PWD=$MYSQL_ADDON_PASSWORD mysql $PARAMS -sse"$SSE")

if [ "$TABLE_COUNT" -eq 0 ]; then
  echo "Database is empty, we fill it with the default data."
  MYSQL_PWD=$MYSQL_ADDON_PASSWORD mysql $PARAMS < db/mysql.sql 
  
else
  echo "Database contains $TABLE_COUNT tables."
fi

rm init.sh

Vous devrez le lancer lors du déploiement de l'application :

clever env set CC_PRE_BUILD_HOOK "bash init.sh"

Vous n'avez alors plus qu'à redéployer votre application qui utilisera désormais la base de données MySQL pour stocker ses données plutôt que les sessions PHP :

git add settings.php && git commit -m "Add MySQL support"
clever deploy && clever open

Si jamais cela ne fonctionne pas, regardez les erreurs dans les logs de votre instance dans la Console ou via :

clever logs

Envie d'en savoir plus ?

Pour découvrir plus en détails l'hébergement d'applications PHP sur Clever Cloud ou nos services de bases de données managées ? Venez nous rencontrer au PHP Forum qui se tient du 12 au 13 octobre à Disneyland Paris. Nous serons également présents à Devoxx Maroc et à Volcamp :

• C'est la rentrée des évènements pour Clever Cloud