Bonjour à tous. Aujourd'hui, nous partageons avec vous la dernière partie de l'article
«Tester l'infrastructure en tant que code à l'aide de Pulumi» , dont une traduction a été préparée spécifiquement pour les étudiants du cours
«DevOps Practices and Tools» .
Test de déploiement
Le style de test testé est une approche puissante; il nous permet de tester une boîte blanche pour vérifier l'intérieur de notre code d'infrastructure. Cependant, cela limite quelque peu ce que nous pouvons vérifier. Les tests sont effectués sur la base du plan de déploiement en mémoire créé par Pulumi avant le déploiement direct et, par conséquent, le déploiement lui-même ne peut pas être testé. Pour de tels cas, Pulumi dispose d'un cadre de test d'intégration. Et ces deux approches fonctionnent très bien ensemble!
Le framework de test d'intégration Pulumi est écrit en Go, et c'est avec son aide que nous testons la plupart de notre code interne. Si l'approche de test unitaire discutée précédemment ressemblait davantage à un test de boîte blanche, alors le test d'intégration est une boîte noire. (Il existe également des options pour des tests internes approfondis.) Ce cadre a été créé afin de prendre le programme Pulumi complet et d'effectuer diverses opérations de cycle de vie pour lui, telles que le déploiement d'une nouvelle pile à partir de zéro, la mise à jour avec des variantes et la suppression, éventuellement plusieurs fois. Nous les exécutons régulièrement (par exemple, la nuit) et comme tests de résistance.
(Nous
nous efforçons de garantir que des capacités de test d'intégration similaires sont dans le SDK de la langue maternelle. Vous pouvez utiliser le framework de test d'intégration Go quelle que soit la langue dans laquelle votre programme Pulumi est écrit).
En exécutant le programme à l'aide de ce cadre, vous pouvez vérifier les éléments suivants:
- Le code de votre projet est syntaxiquement correct et fonctionne sans erreur.
- Les paramètres de configuration de la pile et des secrets fonctionnent et sont interprétés correctement.
- Votre projet peut être déployé avec succès dans votre fournisseur de cloud choisi.
- Votre projet peut être mis à niveau avec succès de l'état initial vers N autres états.
- Votre projet peut être détruit et supprimé avec succès de votre fournisseur de cloud.
Comme nous le verrons bientôt, ce cadre peut également être utilisé pour effectuer la validation d'exécution.
Test d'intégration simple
Pour voir cela en action, nous allons regarder le
pulumi/examples , car notre équipe et la communauté Pulumi l'utilisent pour tester leur propre pool de requêtes, de validations et de builds nocturnes.
Vous trouverez ci-dessous un test simplifié de notre
exemple, qui effectue le provisionnement du compartiment S3 et de certains autres objets :
example_test.go:
package test import ( "os" "path" "testing" "github.com/pulumi/pulumi/pkg/testing/integration" ) func TestExamples(t *testing.T) { awsRegion := os.Getenv("AWS_REGION") if awsRegion == "" { awsRegion = "us-west-1" } cwd, _ := os.Getwd() integration.ProgramTest(t, &integration.ProgramTestOptions{ Quick: true, SkipRefresh: true, Dir: path.Join(cwd, "..", "..", "aws-js-s3-folder"), Config: map[string]string{ "aws:region": awsRegion, }, }) }
Ce test passe par le cycle de vie de base de la création, de la modification et de la destruction de la pile pour le
aws-js-s3-folder . Il faudra environ une minute pour signaler le test réussi:
$ go test . PASS ok ... 43.993s
Il existe de nombreuses options pour personnaliser le comportement de ces tests. Voir la
structure ProgramTestOptions pour une liste complète des options. Par exemple, vous pouvez configurer le point de terminaison Jaeger pour tracer (
Tracing ), indiquer que vous vous attendez à ce que le test
ExpectFailure lors d'un test négatif (
ExpectFailure ), appliquer une série de «modifications» au programme pour des transitions d'état successives (
EditDirs ), et bien plus encore. Voyons comment les utiliser pour vérifier le déploiement des applications.
Vérification des propriétés des ressources
L'intégration mentionnée ci-dessus garantit que notre programme "fonctionne" - il ne plante pas. Mais que se passe-t-il si nous voulons vérifier les propriétés de la pile résultante? Par exemple, que certains types de ressources ont été (ou n'étaient pas) préparés et qu'ils ont certains attributs.
Le paramètre
ExtraRuntimeValidation pour
ExtraRuntimeValidation nous permet de regarder l'état enregistré par Pulumi après le déploiement (état post-déploiement) afin que nous puissions faire des vérifications supplémentaires. Cela inclut un instantané complet de l'état de la pile résultante, y compris la configuration, les valeurs de sortie exportées, toutes les ressources et leurs valeurs de propriété, ainsi que toutes les dépendances entre les ressources.
Pour voir un exemple de base de cela, vérifions que notre programme crée un
compartiment S3 :
integration.ProgramTest(t, &integration.ProgramTestOptions{
Maintenant, lorsque nous exécutons le test go, il passera non seulement par la batterie de tests de cycle de vie, mais aussi, après avoir déployé avec succès la pile, il effectuera une vérification supplémentaire de l'état résultant.
Tests d'exécution
Jusqu'à présent, tous les tests ont porté exclusivement sur le comportement de déploiement et sur le modèle de ressource Pulumi. Et si vous voulez vérifier que votre infrastructure préparée fonctionne vraiment? Par exemple, que la machine virtuelle fonctionne, le compartiment S3 contient ce que nous attendons, etc.
Vous avez peut-être déjà compris comment procéder: l'option
ExtraRuntimeValidation pour
ProgramTestOptions est une excellente opportunité pour cela. À ce stade, vous exécutez un test Go arbitraire avec accès à l'état complet des ressources de votre programme. Cet état comprend des informations telles que les adresses IP des machines virtuelles, les URL et tout ce qui est nécessaire pour une interaction réelle avec les applications et l'infrastructure cloud reçues.
Par exemple, notre programme de test exporte une propriété de
websiteUrl appelée
websiteUrl , qui est l'URL complète à laquelle nous pouvons obtenir le
index document personnalisé. Bien que nous puissions fouiller dans le fichier d'état pour trouver le
bucket et lire directement cette propriété, dans de nombreux cas, nos piles exportent des propriétés utiles, telles que celle-ci, qui nous sont pratiques pour vérifier:
integration.ProgramTest(t, &integration.ProgramTestOptions{
Comme nos précédentes vérifications d'exécution, cette vérification sera effectuée immédiatement après avoir augmenté la pile, et tout cela en réponse à un simple appel à
go test . Et ce n'est que la pointe de l'iceberg - toutes les fonctionnalités de test Go que vous pouvez écrire dans le code sont disponibles.
Intégration continue des infrastructures
Il est bon de pouvoir exécuter des tests sur un ordinateur portable lorsque de nombreuses modifications sont apportées à l'infrastructure pour les tester avant de les envoyer aux revues de code. Mais nous et bon nombre de nos clients testons l'infrastructure à différentes étapes du cycle de vie du développement:
- Dans chaque pool ouvert, la demande de test avant la fusion.
- En réponse à chaque validation, vérifiez à nouveau que la fusion a été effectuée correctement.
- Périodiquement, par exemple, la nuit ou chaque semaine pour des tests supplémentaires.
- Dans le cadre de tests de performances ou de tests de stress, qui sont généralement effectués sur une longue période et exécutent des tests en parallèle et / ou déploient le même programme plusieurs fois.
Pour chacun d'eux, Pulumi prend en charge l'intégration avec votre système d'intégration continue préféré. Avec une intégration continue, cela vous offre la même couverture de test pour votre infrastructure que pour les logiciels d'application.
Pulumi prend en charge les systèmes CI courants. En voici quelques uns:
Pour plus d'informations, consultez la documentation de
livraison continue .
Environnements éphémères
Une fonctionnalité très puissante qui s'ouvre est la possibilité de déployer des environnements éphémères uniquement à des fins de test d'acceptation. Le concept de
projet et de pile Pulumi est conçu pour déployer et démolir facilement des environnements complètement isolés et indépendants, le tout en quelques commandes CLI simples ou via un cadre de test d'intégration.
Si vous utilisez GitHub, Pulumi propose l'
application GitHub , qui vous aidera à connecter les tests d'acceptation au pool de demandes à l'intérieur de votre pipeline CI. Installez simplement l'application dans le référentiel GitHub, et Pulumi ajoutera des informations sur l'aperçu de l'infrastructure, les mises à jour et les résultats des tests à votre CI et à votre pool de demandes:
Lorsque vous utilisez Pulumi pour vos tests d'acceptation de base, vous disposerez de nouvelles capacités d'automatisation qui amélioreront les performances de l'équipe et donneront confiance dans la qualité des changements.
Résumé
Dans cet article, nous avons vu que lors de l'utilisation de langages de programmation à usage général, de nombreuses méthodes de développement de logiciels qui étaient utiles dans le développement de nos applications deviennent disponibles pour nous. Ils incluent les tests unitaires, les tests d'intégration et leur interaction pour effectuer des tests d'exécution approfondis. Les tests sont faciles à exécuter à la demande ou dans votre système CI.
Pulumi est un logiciel open source, il est gratuit à utiliser et fonctionne avec vos langages de programmation et nuages préférés -
essayez-le aujourd'hui !
→
La première partie