Automatisation des déploiements d'applications avec F5 BIG-IP et Puppet

Alors que les entreprises adoptent des stratégies de transformation numérique pour s’aventurer dans de nouvelles sources de revenus ou simplement rester compétitives, l’un des principaux moteurs est le besoin de rapidité, ou la capacité à offrir rapidement des expériences client vraiment 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, vulnérable aux erreurs humaines et nécessite un investissement opérationnel important pour sa gestion. Il est impératif d’automatiser non seulement l’infrastructure réseau prenant en charge les déploiements d’applications, mais également les services réseau tels que le DNS et l’équilibrage de charge, dans le cadre d’un pipeline d’intégration/développement continu (CI/CD) étendu.

Grâce à l’automatisation du réseau, les organisations peuvent atteindre une plus grande agilité, ce qui permet un réseau plus dynamique et plus fiable, une efficacité opérationnelle accrue, un temps de déploiement réduit et des déploiements d’applications plus cohérents.

La programmabilité est un élément clé de l’automatisation opérationnelle. Au fil des années, F5 a adopté ce concept et prend en charge la programmabilité sur tous les contrôleurs de distribution d'applications (ADC) F5® BIG-IP®, permettant ainsi l'agilité et l'extensibilité de la structure de services du réseau d'applications. Les éditions physiques et virtuelles des ADC BIG-IP présentent des plans de gestion, de contrôle et de données flexibles et programmables :

• F5 iControl® : Utilise SOAP/XML/REST pour garantir des communications ouvertes entre des systèmes différents et automatiser les fonctionnalités BIG-IP. Le gem F5-iControl est également pris en charge pour vous permettre de vous connecter à un appareil F5 au moyen de ses services Web.
• F5 iApps® : Les ensembles de fonctionnalités modélisés aident à automatiser la configuration et le déploiement des applications sur les appareils F5.

• F5 iCall™ : Ce framework de script basé sur Tcl vous permet d'exécuter des commandes TMSH (interface de ligne de commande TMOS Shell) avec les commandes Tcl attendues, pour diriger la configuration d'un périphérique F5 en cours d'exécution.

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

Une approche globale de la programmabilité du réseau aide les opérations à réagir à la demande aux événements ou opportunités opérationnels et commerciaux. Le portefeuille de produits F5 offrant une programmabilité réseau permet aux organisations d'automatiser et d'orchestrer efficacement.

F5 et Puppet se sont associés pour répondre au besoin d’agilité des entreprises modernes afin de soutenir l’intégration continue et le déploiement continu (CI/CD) grâce à une solution complète. Puppet propose un outil de gestion de configuration pris en charge commercialement, Puppet Enterprise, 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, et aide les organisations à fournir des applications de manière plus transparente.

Grâce à son approche déclarative et basée sur des modèles en matière d'automatisation informatique, Puppet Enterprise vous permet d'exécuter des fonctions allant de l'automatisation de tâches simples et répétitives au déploiement de clouds publics, privés et hybrides à grande échelle. La capacité de modéliser, de tester, puis de déployer des modifications de configuration dans ces environnements cloud garantit une utilisation efficace des ressources de votre infrastructure ; grâce à l’extensibilité de Puppet via des modules, les organisations peuvent s’appuyer sur le cadre existant pour prendre en charge leurs appareils BIG-IP.

Une infrastructure Puppet typique dispose d’agents logiciels installés sur chaque système géré. Ces agents envoient périodiquement plusieurs éléments d’information appelés « faits » sur le système à un serveur maître Puppet. En retour, le maître des marionnettes utilise les faits reçus ainsi qu'un manifeste (un programme Puppet composé de code Puppet pour compiler un catalogue définissant la configuration finalisée) avant de renvoyer le catalogue à l'agent. L'agent peut alors appliquer l'état du système tel que défini par le catalogue. 

Contrairement à un cas de serveur où l'agent logiciel s'exécute directement dans le nœud, l'infrastructure Puppet vous permet de configurer un proxy qui exécute l'agent pour un périphérique BIG-IP. Vous pouvez désormais gérer le périphérique BIG-IP avec Puppet et profiter des avantages offerts par la solution. L'agent Puppet peut résider sur un serveur distinct du maître Puppet, ou ils peuvent s'exécuter sur le même serveur.

Les fichiers de langue Puppet sont appelés manifestes et sont nommés avec l'extension de fichier .pp . Le cœur du langage Puppet est la déclaration des ressources. Toutes les autres parties du langage existent pour ajouter de la flexibilité et de la commodité à la manière dont les ressources sont déclarées. Le maître des marionnettes utilise toujours le manifeste principal défini par l'environnement du nœud actuel, où vous pouvez décrire les ressources de manière déclarative. 

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

1. Le proxy exécutant l'agent Puppet récupère périodiquement des informations sur le périphérique BIG-IP via un accès shell distant, des API ou d'autres moyens, puis les transmet au maître Puppet sous forme de faits.
2. Le maître des marionnettes 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 extrait de code gem iControl pour créer la configuration finale sur le périphérique BIG-IP.
4. Les fichiers gemmes iControl sont utilisés pour traduire les paramètres de configuration des nœuds en messages iControl, afin d'appliquer l'état décrit via des API.

Deux fonctionnalités clés de cette implémentation conjointe sont l'API iControl et la gestion des périphériques réseau Puppet. Les API F5 iControl assurent la communication entre le proxy Puppet et les périphériques F5 BIG-IP, tandis que Puppet Network Device Management aide les organisations à configurer les périphériques réseau. À l'aide du périphérique réseau Puppet et de l'API F5 iControl, vous pouvez déployer le module Puppet F5 et apporter la gestion Puppet aux périphériques BIG-IP. Les modules Puppet F5 offrent des ressources pour la gestion des objets BIG-IP, notamment le déploiement et la gestion de serveurs virtuels, ainsi que la configuration et la gestion de pools et de membres de pool. Puppet utilise les modules F5 pour rechercher les ressources définies pour les périphériques BIG-IP et charge automatiquement toute classe personnalisée ou type défini stocké dans les modules F5.

Cette solution commune F5 et Puppet vous aide à :

• Gérez l'infrastructure de calcul et de réseau avec le même outil pour une plus grande efficacité.
• Éliminez les transferts chronophages entre les systèmes et les équipes réseau.
• Appliquez la cohérence de la configuration de vos appareils BIG-IP (chaque fois que la configuration s'écarte de l'état souhaité, Puppet la ramènera automatiquement à l'état configuré).
• Bénéficiez d'une évolutivité et d'une élasticité de service, avec la possibilité d'écrire la configuration une fois et de l'appliquer à de nombreux systèmes à grande échelle.
• Activer la reproduction rapide. Lorsqu'il est temps de faire passer une application de la préproduction à la production, il vous suffit d'exécuter Puppet, et Puppet configurera tout de la même manière qu'il l'a fait dans vos environnements de test.
• Augmentez la vitesse de livraison des applications.

Les modules Puppet F5 peuvent créer et configurer des objets BIG-IP, notamment des nœuds de serveur, des pools et des serveurs virtuels, nécessaires au déploiement d'applications classiques. Lorsqu'il s'agit de déployer plusieurs périphériques BIG-IP, les organisations peuvent utiliser les modules Puppet pour automatiser toutes les tâches initiales d'intégration BIG-IP telles que les licences des périphériques, les paramètres DNS et NTP, les VLAN internes et externes, les adresses IP autonomes et les domaines de routage.

Pour configurer une application HTTP classique sur un périphérique BIG-IP, vous devez configurer 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 périphérique BIG-IP, mais la configuration de plusieurs périphériques F5 éventuellement répartis sur plusieurs centres de données pour fournir de grandes applications d'entreprise est complexe, prend du temps et est sujette aux erreurs. Avec le manifeste Puppet déclaratif basé sur un modèle, les organisations peuvent gérer et automatiser le déploiement d'applications sur plusieurs périphériques BIG-IP dans des centres de données.

Pour démarrer le déploiement, installez le maître Puppet et créez un système proxy capable d'exécuter l'agent Puppet. De plus, vous devez installer toutes les dépendances, y compris les gemmes iControl et Faraday, dans l'environnement Puppet Ruby sur l'hôte proxy (agent Puppet). Le déploiement est illustré dans la figure 2.

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

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

Dans l’exemple ci-dessus, administrateur : admin@10.192.74.111 fait référence à la connexion de Puppet pour l'appareil F5 : <NOM D'UTILISATEUR>:<MOT DE PASSE>@<ADRESSE IP DE BIGIP>.

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

nœud bigip1 {
f5_node { '/Common/web_server_1':
assurer => 'présent',
adresse => '10.1.20.11',
description => 'Nœud de serveur Web 1',
disponibilité_requirement => 'tous',
moniteurs de santé => ['/Common/icmp'],
}->

f5_node { '/Common/web_server_2':
assurer => 'présent',
adresse => '10.1.20.12',
description => 'Nœud de serveur Web 2',
disponibilité_requirement => 'tous',
moniteurs de santé => ['/Common/icmp'],
}->

f5_node { '/Common/web_server_3':
assurer => 'présent',
adresse => '10.1.20.13',
description => 'Nœud de serveur Web 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',
supplier => '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 présente trois tâches :

1. Vous devez d’abord établir 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 nombre minimum de paramètres possible et un moniteur de santé qui envoie un ping directement à chaque serveur pour s'assurer qu'il est toujours réactif.
2. Ensuite, établissez le pool de serveurs. Le module « f5_pool » crée un pool nommé web_pool et ajoute également les membres du nœud créés ci-dessus en tant que membres du pool.
3. Le module « f5_virtualserver » crée un serveur virtuel http-vs avec un profil http et le web_pool créé ci-dessus.

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

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

$ sudo puppet device -v --user=root –trace
Info : démarrage de l'application de la configuration à bigip1 à l'adresse https://10.192.74.111:443
Info : Récupération des pluginfacts
Infos : Récupération du plugin
Infos : Catalogue de mise en cache pour bigip1
Info : Application de la version de configuration « 1498175426 »
Remarque : /Stage[main]/Main/Node[bigip1]/F5_node[/Common/web_server_1]/ensure : créé
Remarque : /Stage[main]/Main/Node[bigip1]/F5_node[/Common/web_server_2]/ensure : créé
Remarque : /Stage[main]/Main/Node[bigip1]/F5_node[/Common/web_server_3]/ensure : créé
Remarque : /Stage[main]/Main/Node[bigip1]/F5_pool[/Common/web_pool]/ensure : créé
Remarque : /Stage[main]/Main/Node[bigip1]/F5_virtualserver[/Common/http_vs]/ensure : créé
Infos : Nœud[bigip1] : Annulation de la planification de tous les événements sur Node[bigip1]
Remarque : Catalogue appliqué en 0,50 seconde

Puppet a maintenant créé un nouveau serveur virtuel entièrement configuré (Figure 3). Ce serveur équilibre la charge des applications HTTP sur un pool nouvellement créé (Figure 4). Le pool comprend trois serveurs Web nouvellement créés (Figure 5).

Tous les modules Puppet F5 sont idempotents, ce qui signifie que les tâches sont exécutées uniquement 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 à l'adresse https://10.192.74.111:443
Info : Récupération des pluginfacts
Infos : Récupération du plugin
Infos : Catalogue de mise en cache pour bigip1
Info : Application de la version de configuration « 1498522983 »
Remarque : Catalogue appliqué en 1,51 seconde

L'automatisation est un élément clé de DevOps et de CI/CD, et commence souvent par la gestion de la configuration. La solution conjointe F5 et Puppet permet aux équipes d'exploitation de déployer, d'automatiser et de gérer la configuration d'une pile d'infrastructure d'application complète. Cela donne aux développeurs d'applications la possibilité d'augmenter et de diminuer de manière élastique les ressources d'infrastructure, d'automatiser les tests d'application et de réduire les délais de développement d'applications. Ainsi, les organisations peuvent atteindre des niveaux d’agilité et d’extensibilité sans précédent.

Pour en savoir plus sur la manière dont la solution commune F5 et Puppet peut aider votre entreprise, veuillez visiter forge.puppet.com/f5/f5