Automatiser les déploiements d’applications avec F5 BIG-IP et Puppet

Introduction

Alors que les entreprises mettent en œuvre des stratégies de transformation numérique pour explorer de nouvelles sources de revenus ou simplement rester compétitives, l’un des principaux moteurs est le besoin de rapidité, autrement dit la capacité à offrir rapidement des expériences client véritablement exceptionnelles. À mesure que les organisations adoptent les méthodologies DevOps, elles constatent que les architectures réseau actuelles constituent un facteur limitant. L’architecture réseau traditionnelle est statique, sujette aux erreurs humaines et nécessite d’importants investissements opérationnels pour être gérée. Il est impératif d’automatiser non seulement l’infrastructure réseau qui prend en charge les déploiements d’applications, mais aussi les services réseau tels que le DNS et l’équilibrage de charge, dans le cadre d’un pipeline étendu d’intégration et de développement continus (CI/CD).

Grâce à l’automatisation du réseau, les organisations peuvent gagner en agilité, ce qui leur permet de bénéficier d’un réseau plus dynamique et plus fiable, d’une efficacité opérationnelle accrue, de délais de déploiement réduits et de déploiements d’applications plus cohérents.

La programmabilité de F5 améliore la productivité des équipes IT et DevOps

La programmabilité est un facteur clé de l’automatisation des opérations. Au fil des années, F5 a adopté ce concept et prend en charge la programmabilité sur l’ensemble des contrôleurs de mise à disposition d’applications (ADC) F5® BIG-IP®, offrant ainsi agilité et extensibilité au sein de l’infrastructure de services réseau applicatifs. Les éditions physiques et virtuelles des ADC BIG-IP disposent de plans de gestion, de contrôle et de données flexibles et programmables :

Plan de gestion

• F5 iControl® : utilise SOAP/XML/REST pour garantir des communications ouvertes entre des systèmes hétérogènes et automatiser les fonctionnalités de BIG-IP. La gem F5-iControl est également prise en charge afin de vous permettre de vous connecter à un appareil F5 au moyen de ses services web.
• F5 iApps® : des ensembles de fonctionnalités basés sur des modèles permettent d’automatiser la configuration et le déploiement d’applications sur les appareils F5.

Plan de contrôle

• F5 iCall™ : ce framework de script basé sur Tcl vous permet d’exécuter des commandes TMSH (interface de ligne de commande de TMOS) ainsi que les commandes Tcl habituelles afin de piloter la configuration d’un appareil F5 en cours d’exécution.

Plan de données

• F5 iRules® : langage de script basé sur Tcl, hautement personnalisable et programmable, iRules vous permet d’inspecter, d’analyser, de modifier, d’acheminer, de rediriger ou de manipuler le trafic en temps réel. Son évolution suivante, iRules Language eXtensions (LX), permet d’utiliser les fonctionnalités de node.js sur la plateforme BIG-IP (v12.1).

Une approche globale de la programmabilité des réseaux permet aux équipes opérationnelles de réagir à la demande aux événements ou aux opportunités d’ordre opérationnel et commercial. La gamme de produits F5 dédiés à la programmabilité des réseaux permet aux organisations d’automatiser et d’orchestrer efficacement leurs opérations.

La solution conjointe de F5 et Puppet

F5 et Puppet se sont associés pour répondre au besoin d’agilité des entreprises modernes en matière d’intégration et de déploiement continus (CI/CD), grâce à une solution complète. Puppet propose Puppet Enterprise, un outil de gestion de la configuration bénéficiant d’un support commercial, qui fournit une approche unifiée et définie par logiciel pour automatiser la gestion des ressources de calcul, de réseau et de stockage, tout en aidant les entreprises à déployer leurs applications de manière plus fluide.

Grâce à son approche déclarative de l’automatisation informatique, fondée sur des modèles, Puppet Enterprise vous permet aussi bien d’automatiser des tâches simples et répétitives que de déployer des clouds publics, privés et hybrides à grande échelle. La possibilité de modéliser, de tester, puis de déployer les modifications de configuration dans ces environnements cloud garantit une utilisation efficace des ressources de votre infrastructure. Grâce à l’extensibilité de Puppet au moyen de modules, les entreprises peuvent s’appuyer sur le cadre existant pour prendre en charge leurs appareils BIG-IP.

Une infrastructure Puppet classique comporte des agents logiciels installés sur chaque système géré. Ces agents envoient régulièrement au serveur maître Puppet diverses informations sur le système, appelées « facts ». Le serveur maître Puppet utilise alors les facts reçus ainsi qu’un manifeste — un programme Puppet composé de code Puppet — pour compiler un catalogue définissant la configuration finale, puis renvoie ce catalogue à l’agent. L’agent peut ensuite appliquer l’état du système défini par le catalogue.

Contrairement au cas d’un serveur, où l’agent logiciel s’exécute directement sur le nœud, l’infrastructure Puppet vous permet de configurer un proxy qui exécute l’agent pour un appareil BIG-IP. Vous pouvez ainsi gérer l’appareil BIG-IP avec Puppet et profiter des avantages offerts par cette solution. L’agent Puppet peut résider sur un serveur distinct du serveur maître Puppet, ou les deux peuvent s’exécuter sur le même serveur.

Les fichiers du langage Puppet sont appelés manifestes et portent l’extension .pp . Le cœur du langage Puppet consiste à déclarer des ressources. Toutes les autres composantes du langage visent à rendre la déclaration des ressources plus souple et plus pratique. Le maître Puppet utilise toujours le manifeste principal défini par l’environnement du nœud actuel, dans lequel vous pouvez décrire les ressources de manière déclarative.

Le flux de données de la solution conjointe F5 et Puppet est illustré à la figure 1.

1. Le proxy exécutant l’agent Puppet récupère régulièrement des informations sur le dispositif BIG-IP via un accès distant à l’interpréteur de commandes, des API ou tout autre moyen, puis les transmet au serveur maître Puppet sous forme de faits.
2. Le serveur maître Puppet compile un catalogue et le renvoie à l’agent ou au proxy.
3. Le proxy Puppet convertit le catalogue reçu du maître Puppet en un extrait de code utilisant la gemme iControl afin de créer la configuration finale sur le dispositif BIG-IP.
4. Les fichiers du gem iControl servent à convertir les paramètres de configuration des nœuds en messages iControl afin d’appliquer l’état décrit via des API.

Figure 1 : la solution conjointe de F5 et Puppet.

Deux fonctionnalités essentielles à cette mise en œuvre conjointe sont l’API iControl et Puppet Network Device Management. Les API F5 iControl assurent la communication entre le proxy Puppet et les appareils F5 BIG-IP, tandis que Puppet Network Device Management aide les entreprises à configurer leurs appareils réseau. Grâce à Puppet Network Device et à l’API F5 iControl, vous pouvez déployer le module Puppet F5 et gérer les appareils BIG-IP avec Puppet. Les modules Puppet F5 fournissent des ressources permettant de gérer les objets BIG-IP, notamment de déployer et de gérer des serveurs virtuels, ainsi que de configurer et de gérer des pools et leurs membres. Puppet utilise les modules F5 pour trouver les ressources définies pour les appareils BIG-IP et charge automatiquement toute classe personnalisée ou tout type défini stocké dans les modules F5.

Principaux avantages

Cette solution conjointe de F5 et Puppet vous permet de :

• Gérez l’infrastructure de calcul et l’infrastructure réseau avec un même outil pour gagner en efficacité.
• Éliminez les transferts chronophages entre les équipes systèmes et réseaux.
• Garantissez la cohérence de la configuration de vos appareils BIG-IP (chaque fois que la configuration s’écarte de l’état souhaité, Puppet la rétablit automatiquement à l’état configuré).
• Bénéficiez d’une grande évolutivité et de l’élasticité des services, avec la possibilité d’écrire la configuration une seule fois et de l’appliquer à de nombreux systèmes à grande échelle.
• Permettez une reproduction rapide. Lorsqu’il est temps de faire passer une application de la préproduction à la production, il vous suffit d’exécuter Puppet, qui configurera tout exactement comme dans vos environnements de test.
• Accélérez la livraison des applications.

Les modules Puppet F5 permettent de créer et de configurer les objets BIG-IP — notamment les nœuds de serveur, les pools et les serveurs virtuels — nécessaires au déploiement standard d’applications. Lors du déploiement de plusieurs appareils BIG-IP, les entreprises peuvent utiliser les modules Puppet pour automatiser toutes les tâches initiales de mise en service de BIG-IP, telles que l’octroi de licences aux appareils, la configuration des paramètres DNS et NTP, des VLAN internes et externes, des adresses IP propres et des domaines de routage.

Cas d’usage : déploiement d’une application HTTP sur la plateforme BIG-IP

Pour configurer une application HTTP standard sur un appareil BIG-IP, vous devez définir des nœuds, des moniteurs et des profils, déployer des adresses IP virtuelles, et bien plus encore. Cela peut sembler gérable sans automatisation sur un seul appareil BIG-IP, mais la configuration de plusieurs appareils F5, éventuellement répartis entre plusieurs centres de données, afin de fournir des applications d’entreprise de grande envergure est complexe, chronophage et sujette aux erreurs. Grâce au manifeste Puppet déclaratif basé sur un modèle, les entreprises peuvent gérer et automatiser le déploiement d’applications sur plusieurs appareils BIG-IP répartis entre différents centres de données.

Pour commencer le déploiement, installez le serveur maître Puppet et créez un système proxy capable d’exécuter l’agent Puppet. Vous devez également installer toutes les dépendances, notamment les gems iControl et Faraday, dans l’environnement Ruby de Puppet sur l’hôte proxy (agent Puppet). Le déploiement est illustré à la Figure 2.

Figure 2 : déploiement de la solution conjointe F5 et Puppet.

Créer un fichier device.conf

Avant de pouvoir utiliser le module F5, vous devez créer un fichier device.conf dans le répertoire de configuration de Puppet (soit /etc/puppet soit /etc/puppetlabs/puppet) sur le proxy Puppet :

[bigip1]
type f5
url https://admin:admin@10.192.74.111

Dans l’exemple ci-dessus, admin:admin@10.192.74.111 correspond aux identifiants de connexion utilisés par Puppet pour le périphérique F5 : <NOM D’UTILISATEUR>:<MOT DE PASSE>@<ADRESSE IP DU BIGIP>.

Classez vos nœuds sur le serveur maître Puppet

Ensuite, saisissez la configuration dans l’instruction de classe ou la déclaration de nœud appropriée de votre fichier site.pp, dans le manifeste de nœud <devicecertname>.pp ou dans un fichier manifeste profiles::<profile_name>. Voici un exemple de fichier manifeste Puppet (site.pp) permettant de configurer une application HTTP sur la plateforme BIG-IP :

node bigip1 {
f5_node { '/Common/web_server_1':
ensure => 'present',
address => '10.1.20.11',
description => 'Web Server Node 1',
availability_requirement => 'all',
health_monitors => ['/Common/icmp'],
}->

f5_node { '/Common/web_server_2':
ensure => 'present',
address => '10.1.20.12',
description => 'Web Server Node 2',
availability_requirement => 'all',
health_monitors => ['/Common/icmp'],
}->

f5_node { '/Common/web_server_3':
ensure => 'present',
address => '10.1.20.13',
description => 'Web Server Node 3',
availability_requirement => 'all',
health_monitors => ['/Common/icmp'],
}->

f5_pool { '/Common/web_pool':
ensure => 'present',
members => [
{ name => '/Common/web_server_1', port => '80', },
{ name => '/Common/web_server_2', port => '80', },
{ name => '/Common/web_server_3', port => '80', },
],
availability_requirement => 'all',
health_monitors => ['/Common/http_head_f5'],
}->

f5_virtualserver { '/Common/http_vs':
ensure => 'present',
provider => 'standard',
default_pool => '/Common/web_pool',
destination_address => '10.1.10.240',
destination_mask => '255.255.255.255',
http_profile => '/Common/http',
service_port => '80',
protocol => 'tcp',
source => '0.0.0.0/0',
source_address_translation => 'automap'
}

}

Cet exemple comporte trois tâches :

1. Vous devez d’abord configurer vos serveurs web. Le module F5 appelé « f5_node » ajoute trois serveurs web : web_server_1, web_server_2 et web_server_3, chacun avec le moins de paramètres possible et un moniteur d’intégrité qui envoie directement une requête ping à chaque serveur pour vérifier qu’il répond toujours.
2. Ensuite, configurez le pool de serveurs. Le module « f5_pool » crée un pool nommé web_pool et y ajoute également comme membres les nœuds créés précédemment.
3. Le module « f5_virtualserver » crée un serveur virtuel http-vs avec le profil http et le pool web_pool créé ci-dessus.

Exécuter puppet device

Avant d’exécuter puppet device (commande pour Puppet Network Device), aucun serveur virtuel, pool ou nœud n’est configuré sur l’appareil BIG-IP. L’exécution de la commande puppet device -v --user=root permet au nœud proxy de l’appareil de générer un certificat et d’appliquer vos classifications à l’appareil F5.

Comme indiqué ci-dessous, toutes les tâches ont été effectuées avec succès, sans aucun échec.

$ sudo puppet device -v --user=root –trace
Info : début de l’application de la configuration à bigip1 sur https://10.192.74.111:443
Info : récupération des faits du plug-in
Info : récupération du plug-in
Info : mise en cache du catalogue pour bigip1
Info : application de la version de configuration '1498175426'
Notification : /Stage[main]/Main/Node[bigip1]/F5_node[/Common/web_server_1]/ensure : créé
Notification : /Stage[main]/Main/Node[bigip1]/F5_node[/Common/web_server_2]/ensure : créé
Notification : /Stage[main]/Main/Node[bigip1]/F5_node[/Common/web_server_3]/ensure : créé
Notification : /Stage[main]/Main/Node[bigip1]/F5_pool[/Common/web_pool]/ensure : créé
Notification : /Stage[main]/Main/Node[bigip1]/F5_virtualserver[/Common/http_vs]/ensure : créé
Info : Node[bigip1] : annulation de la planification de tous les événements sur Node[bigip1]
Notification : catalogue appliqué en 0,50 seconde

Puppet a maintenant créé un nouveau serveur virtuel entièrement configuré (figure 3). Ce serveur répartit la charge des applications HTTP sur un pool nouvellement créé (figure 4). Ce pool comprend trois nouveaux serveurs web (figure 5).

Figure 3 : serveur virtuel (« http_vs ») créé par Puppet.

Figure 4 : le pool BIG-IP créé par Puppet.

Figure 5 : le pool BIG-IP créé par Puppet.

Tous les modules Puppet F5 sont idempotents, ce qui signifie que les tâches ne sont exécutées que si l’état du nœud ne correspond pas à l’état configuré ou souhaité. En d’autres termes, si le même manifeste est exécuté à nouveau, Puppet ne reconfigure pas ces objets.

Info : début de l’application de la configuration à bigip1 sur https://10.192.74.111:443
Info : récupération de pluginfacts
Info : récupération du plugin
Info : mise en cache du catalogue pour bigip1
Info : application de la version de configuration '1498522983'
Notification : catalogue appliqué en 1,51 seconde

Conclusion

L’automatisation est un élément clé du DevOps et de la CI/CD, et commence souvent par la gestion de la configuration. La solution conjointe de F5 et Puppet permet aux équipes d’exploitation de déployer, d’automatiser et de gérer la configuration de l’ensemble de la pile d’infrastructure applicative. Les développeurs d’applications peuvent ainsi adapter de manière élastique les ressources d’infrastructure à la hausse comme à la baisse, automatiser les tests applicatifs et réduire les délais de développement des applications. Les entreprises peuvent ainsi atteindre des niveaux d’agilité et d’extensibilité sans précédent.

Pour en savoir plus sur la manière dont la solution conjointe de F5 et Puppet peut aider votre entreprise, rendez-vous sur forge.puppet.com/f5/f5

PUBLIÉ LE 5 OCTOBRE 2017