Comment Testcontainers rationalise le développement d’applications alimentées par l’IA
Dans le paysage économique actuel, rapide et de plus en plus concurrentiel, les organisations doivent trouver des moyens d’accélérer l’achèvement de leurs projets de transformation numérique. Minimisez les retards dans le déploiement de nouvelles applications ou fonctionnalités, et vous pourrez en récolter les bénéfices en matière de productivité et d’efficacité en moins de temps, tout en prenant l’avantage sur vos concurrents. Prolonger le développement de nouveaux logiciels ou la publication de mises à jour, en revanche, peut éroder votre part de marché, car d’autres entreprises de votre secteur innovent plus rapidement.
Les conteneurs sont devenus la technologie de référence pour les entreprises qui cherchent à rationaliser leurs pratiques de développement d’applications, permettant aux développeurs de créer des applications plus sécurisées, robustes et évolutives - en moins de temps que jamais.
Dans cet article, inspiré par cette présentation d’Oleg Šelajev lors d’un récent Unstructured Data Meetup organisé par Zilliz, nous explorons le concept de conteneurisation et l’un de ses outils essentiels, Docker, ainsi que la façon dont ils réduisent la complexité du processus de développement d’applications. Nous nous intéresserons ensuite à un framework open source, Testcontainers, qui étend considérablement les capacités de Docker - permettant aux développeurs de rationaliser le développement d’applications alimentées par l’IA.
Que sont les conteneurs ?
Les conteneurs sont des packages standardisés de code applicatif contenant tous les composants requis, notamment les binaires, dépendances, bibliothèques et fichiers de configuration, afin de s’exécuter dans n’importe quel environnement. Traditionnellement, les applications étaient monolithiques, avec différents composants au sein d’une seule base de code. Aujourd’hui, les développeurs divisent le logiciel en composants selon leur fonction ou service, chacun avec sa base de code et ses dépendances–c’est la conteneurisation ou l’architecture de microservices.
Les avantages des conteneurs incluent :
Agilité commerciale accrue : diviser les applications en services permet aux développeurs de travailler simultanément sur différentes parties d’un projet. De même, la modularité des conteneurs permet des mises à jour et de nouvelles fonctionnalités sans modifier l’ensemble de l’application.
Évolutivité améliorée : si une application peut être empaquetée dans un conteneur, il suffit de déployer un conteneur supplémentaire pour créer une autre instance. Dans les applications modulaires, pendant ce temps, les équipes peuvent simplement lancer de nouveaux conteneurs pour le service qui approche de sa capacité maximale.
Efficacité accrue : parce que les conteneurs sont hautement portables et indépendants de la plateforme, les développeurs n’ont pas à consacrer du temps à configurer et maintenir différents environnements.
Coûts réduits : décharger les développeurs de la responsabilité de gérer les serveurs et les environnements les rend plus productifs ailleurs, c.-à-d. dans le développement effectif des applications ! Cela réduit les heures de travail nécessaires pour achever les projets - ce qui en diminue le coût.
Les cas d’utilisation des conteneurs incluent :
Développement d’applications cloud-native : les architectures conteneurisées exploitent pleinement les capacités du cloud, notamment une évolutivité améliorée, un meilleur accès aux données et une cybersécurité plus solide.
Modernisation des applications : les conteneurs peuvent être utilisés pour remanier des applications héritées afin d’accroître leur compatibilité avec un environnement cloud, les rendant plus performantes, plus économes en ressources et plus faciles à mettre à jour.
Prototypage : parce qu’ils sont indépendants de la plateforme, les conteneurs évitent d’avoir à configurer différents environnements pour le développement, les tests, la préproduction, etc. - ce qui permet aux développeurs d’expérimenter plus facilement de nouvelles fonctionnalités.
Appareils Internet des objets (IoT) : légers et économes en ressources, les conteneurs fournissent un mécanisme de déploiement logiciel idéal pour le matériel IoT contraint.
- DevOps : les conteneurs sont utilisés pour créer des environnements cohérents et isolés, garantissant qu’une application s’exécute de la même manière quel que soit l’endroit où elle est déployée, ce qui se traduit par un déploiement plus rapide et une collaboration renforcée entre les équipes de développement et d’exploitation.
Qu’est-ce que Docker ?
Docker est une plateforme qui permet aux développeurs de créer, déployer, configurer et gérer des conteneurs. Docker est en fait tellement synonyme de conteneurs qu’ils sont fréquemment appelés « conteneurs Docker. En réalité, cependant, lorsque les gens mentionnent Docker, ils font en fait référence au moteur Docker : l’environnement d’exécution sur lequel les conteneurs sont construits et exécutés. Ce moteur se situe sous les conteneurs pour virtualiser le système d’exploitation (OS) de l’appareil hôte et leur allouer la quantité optimale de ressources, telles que le CPU et la mémoire.
Cela contraste notablement avec une solution similaire dans les machines virtuelles (VM) - qui nécessitent leur propre OS et leurs propres ressources de calcul. En plus de rendre les conteneurs indépendants de l’environnement, l’utilisation de Docker les rend gourmands en ressources, plus rapides à démarrer et à arrêter, et plus portables que les VM.
Outils Docker largement utilisés
Aussi puissant que soit Docker, sa popularité tient en grande partie à son riche écosystème d’outils et de bibliothèques associés. Voici quelques-uns des outils Docker les plus notables.
Docker Enterprise : une version de Docker conçue pour les déploiements critiques, offrant des fonctionnalités avancées de sécurité, de gestion et d’orchestration pour des versions certifiées, de qualité production.
Docker Swarm : un outil de clustering et d’orchestration pour Docker qui permet aux utilisateurs de gérer plusieurs nœuds Docker comme un seul système virtuel, permettant une mise à l’échelle et un équilibrage de charge plus simples.
Docker Compose : un outil permettant de rationaliser le développement et la gestion d’applications Docker complexes à plusieurs conteneurs.
Kubernetes : Une plateforme open-source d’orchestration de conteneurs qui automatise le déploiement, la mise à l’échelle et la gestion de grandes applications conteneurisées sur des clusters de serveurs.
Vous pouvez en savoir plus sur l’écosystème docker dans cet article https://middleware.io/blog/understanding-the-docker-ecosystem/
Testcontainers : gestion simplifiée des dépendances
Testcontainers est un framework open-source qui fournit des instances légères et modulaires de bases de données, de navigateurs, de courtiers de messages et d’autres dépendances préconfigurées pouvant s’exécuter dans un conteneur. En mettant à la disposition de l’utilisateur une bibliothèque d’API programmatiques pour manipuler les conteneurs, Testcontainers abstrait les détails complexes de chaque dépendance, ce qui facilite leur utilisation. Cela réduit le coût opérationnel des projets tout en encourageant l’expérimentation et en facilitant un développement rationalisé.
Une sélection des plus de 50 intégrations modulaires de Testcontainers
Comme son nom l’indique, Testcontainers offre les gains de productivité les plus significatifs lorsqu’il s’agit de tests d’applications, notamment les tests de couche d’accès aux données, d’intégration et d’acceptation.
Les avantages de la réalisation de tests d’applications avec Testcontainers incluent :
Isolation et cohérence : la conteneurisation des composants garantit que chaque test s’exécute dans un état neuf et connu. Par exemple, tester les bases de données de manière isolée élimine les incohérences qui résultent de configurations de bases de données locales différentes, tandis que les navigateurs conteneurisés permettent des tests d’interface utilisateur plus fiables en remédiant aux variations causées par les configurations de navigateurs locales.
Parité des environnements : les développeurs peuvent effectuer des tests de bout en bout dans un environnement qui ressemble étroitement à la production, réduisant les écarts entre les environnements tout en augmentant la précision des résultats de test.
Gestion des ressources : comme les conteneurs ont des durées d’exécution courtes, vous pouvez gérer les ressources plus efficacement, tout en permettant une exécution et un nettoyage rapides des tests.
Scalabilité et fiabilité : par conséquent, les tests peuvent être facilement mis à l’échelle sans avoir à tenir compte des ressources disponibles.
En plus de rendre les tests d’applications plus faciles et plus efficaces, Testcontainers peut vous aider à développer des applications d’IA indépendantes de l’environnement. Tournons maintenant notre attention vers quelques-unes des autres manières clés dont Testcontainers augmente la productivité.
Exécution d’une instance Milvus
Pour un premier exemple de la façon d’utiliser Testcontainers pour augmenter la productivité, créons une instance Milvus, comme le montre l’exemple de code ci-dessous (tous les exemples de code de cet article sont écrits en Java, mais la bibliothèque Testcontainers est également disponible en Python, Node.js Go, Rust et plusieurs autres langages) :
import io.milvus.client.MilvusServiceClient;
import io.milvus.param.ConnectParam;
import org.testcontainers.milvus.MilvusContainer;
public class MilvusExample {
public static void main(String[] args) {
MilvusContainer milvus = new MilvusContainer("milvusdb/milvus:v2.3.9");
milvus.start();
MilvusServiceClient milvusClient = new MilvusServiceClient(
ConnectParam.newBuilder().withUri(milvus.getEndpoint()).build());
}
}
Au lieu de devoir installer et configurer une instance Milvus distincte et l’intégrer à votre application, Testcontainers fournit une abstraction facile à utiliser qui invoque simplement l’instance depuis le code.
Tout d’abord, nous créons une nouvelle instance d’un conteneur Milvus, en spécifiant la version en passant l’image de conteneur appropriée comme paramètre. En plus de rationaliser le développement d’applications, cela facilite également la mise à jour des applications à l’avenir, car il vous suffit de spécifier l’image mise à jour. À partir de là, nous exécutons le conteneur à l’aide de la méthode .start(), puis nous passons le conteneur comme paramètre à une nouvelle instance d’un client de service Milvus qui vous permet d’interagir avec le service au sein du conteneur.
En plus de créer une instance Milvus en seulement quelques lignes de code, cette approche garantit également que le composant ne se désynchronise jamais des exigences de l’application, car il est invoqué par l’application elle-même.
Intégration d’Ollama et de HuggingFace pour l’intégration des LLM
Une deuxième manière dont Testcontainers améliore la productivité consiste à rationaliser l’intégration de composants d’IA, tels que les LLM, au sein des applications. Cela vous permet d’effectuer facilement des appels LLM depuis le code pour ajouter des fonctionnalités LLM aux applications et, tout aussi important, fait des composants d’IA une partie normale du processus DevOps.
Dans l’extrait de code ci-dessous, nous créons une classe OllamaHuggingFaceContainer, qui étend l’OllamaContainer existant pour lancer une instance exécutant un conteneur Ollama qui exécute un modèle de deep learning téléchargé depuis HuggingFace.
Ollama est une plateforme qui vous permet de servir des modèles pour l’inférence localement sur votre appareil, tandis que HuggingFace est un hub indispensable pour télécharger des modèles d’IA open source. En combinant les deux ressources, vous obtenez l’accès aux dizaines de modèles pris en charge par Ollama, ainsi qu’à tout modèle au format GGUF (GPT-Generated Unified Format), dont il y en a 23 000 sur HuggingFace.
package org.testcontainers.huggingface;
import com.github.dockerjava.api.command.InspectContainerResponse;
import org.testcontainers.containers.ContainerLaunchException;
import org.testcontainers.images.builder.ImageFromDockerfile;
import org.testcontainers.ollama.OllamaContainer;
import org.testcontainers.utility.DockerImageName;
import java.io.IOException;
public class OllamaHuggingFaceContainer extends OllamaContainer {
private final HuggingFaceModel huggingFaceModel;
public OllamaHuggingFaceContainer(HuggingFaceModel model) {
super(DockerImageName.parse("ollama/ollama:0.1.44"));
this.huggingFaceModel = model;
}
Déploiement automatisé des modèles d’IA
Par la suite, comme Testcontainers permet l’invocation de modèles d’IA depuis l’application, il offre également un moyen plus pratique et automatisé de distribuer ces modèles. Bien que les modèles open source soient facilement obtenus depuis HuggingFace, ils sont stockés sous forme d’une série de fichiers et de répertoires dans des dépôts git. Non seulement cela est trop compliqué pour les non-initiés, mais c’est aussi loin d’être la façon la plus pratique pour les développeurs expérimentés de travailler avec des modèles.
Un dépôt HuggingFace typique
Au lieu de configurer et de déployer un modèle manuellement, vous pouvez automatiser le processus avec un script. Cela, encore une fois, réduit la charge administrative pour les développeurs tout en ajoutant un autre niveau d’abstraction pour le modèle lui-même. Ceci est illustré dans le code ci-dessous (qui est un extrait d’un script de test plus long), qui montre comment un modèle peut être spécifié et configuré depuis le code. En plus de spécifier le répertoire à partir duquel le modèle doit être extrait et le modèle exact à utiliser, la variable modelfiledéfinit un modèle de prompt.
public class HuggingFaceVisionModelTest {
@Test
public void visionModelWithHuggingFace() throws IOException {
String imageName = "vision-model-from-HuggingFace";
String repository = "xtuner/llava-phi-3-mini-gguf";
String model = "llava-phi-3-mini-int4.gguf";
String visionAdapter = "llava-phi-3-mini-mmproj-f16.gguf";
String modelfile = """
FROM ./llava-phi-3-mini-int4.gguf
FROM ./llava-phi-3-mini-mmproj-f16.gguf
TEMPLATE """{{ if .System }}<|system|>
{{ .System }}<|end|>
{{ end }}{{ if .Prompt }}<|user|>
{{ .Prompt }}<|end|>
{{ end }}<|assistant|>
{{ .Response }}<|end|>
"""
PARAMETER stop "<|user|>"
PARAMETER stop "<|assistant|>"
PARAMETER stop "<|system|>"
PARAMETER stop "<|end|>"
PARAMETER stop "<|endoftext|>"
PARAMETER num_keep 4
PARAMETER num_ctx 4096
""";
try (
OllamaContainer ollama = new OllamaContainer(DockerImageName.parse(imageName).asCompatibleSubstituteFor("ollama/ollama:0.1.44")).withReuse(true)
) {
try {
ollama.start();
} catch (ContainerFetchException ex) {
createImage(imageName, repository, model, modelfile, visionAdapter);
ollama.start();
}
Comme évoqué plus tôt, cela peut être appliqué à n’importe quel modèle sur Ollama, ainsi qu’au très grand nombre disponible au format GGUF. Déployer un modèle de cette manière facilite également la mise à niveau du modèle d’IA dans les futures itérations de votre application, car vous n’aurez pas à apporter de modifications à l’environnement - seulement aux références au modèle dans le code.
Conclusion
En résumé :
Les conteneurs sont des packages standardisés de code applicatif qui contiennent tous les composants requis, y compris les binaires, les dépendances, les bibliothèques et les fichiers de configuration, pour s’exécuter dans n’importe quel environnement.
Les avantages des conteneurs comprennent :
Une agilité métier accrue
Une évolutivité améliorée
Une efficacité accrue
Des coûts réduits
Les cas d’utilisation des conteneurs comprennent :
Le développement d’applications cloud-native
La modernisation des applications
Le prototypage
Appareils IoT
DevOps
Docker est une plateforme qui permet aux développeurs de créer, déployer, configurer et gérer des conteneurs.
Parmi les outils Docker les plus utilisés, on trouve :
Docker Enterprise
Docker Swarm
Docker Compose
Kubernetes
Testcontainers
Testcontainers est un framework open-source qui fournit des instances modulaires de dépendances préconfigurées pouvant s’exécuter dans un conteneur, telles que des bases de données, des navigateurs et des courtiers de messages.
Testcontainers rationalise les tests d’applications en fournissant :
Isolation et cohérence
Parité des environnements
Gestion des ressources
Évolutivité et fiabilité
Parmi les autres gains de productivité et d’efficacité apportés par Testcontainers, on trouve :
L’abstraction des dépendances, les rendant plus faciles à utiliser, sans avoir à installer de logiciels supplémentaires ni à apporter des modifications à l’environnement ou aux environnements de l’application.
L’invocation simple de composants d’IA, en faisant une partie normale des processus DevOps.
L’abstraction et le déploiement automatisé des LLM.
Lectures complémentaires
Nous vous encourageons à consulter les ressources ci-dessous pour en savoir plus sur les conteneurs, Docker, DevOps et leur rôle dans la création de la prochaine génération de solutions pilotées par l’IA.
Continuer à lire
How to Install and Run OpenClaw (Previously Clawdbot/Moltbot) on Mac
Turn your Mac into an AI gateway for WhatsApp, Telegram, Discord, iMessage, and more — in under 5 minutes.
Zilliz Cloud Update: Smarter Autoscaling for Cost Savings, Stronger Compliance with Audit Logs, and More
What's new in Zilliz Cloud? Smarter autoscaling with scale-down, audit logs GA, enhanced SSO, and Milvus 2.6 in Private Preview.
Why Context Engineering Is Becoming the Full Stack of AI Agents
Discover how context engineering unifies prompts, RAG, and tools to build smarter, production-ready AI agents powered by Milvus.