Auto-Scaling Infrastructure as Code – Calcul élastique sur K5 IaaS
2017-10-10
Machine-translated — the English original is authoritative.
Dans l’article d’aujourd’hui, nous allons passer en revue le déploiement et les tests de la fonctionnalité AutoScaling de l’IaaS K5 de Fujitsu.
Aperçu
Que signifie exactement la fonctionnalité d’auto-scaling de K5 ? Eh bien, imaginez que vous ayez un serveur virtuel dont la demande fluctue, avec des pics et des creux. Prenons l’exemple du serveur web de Ticket Master : 99 % du temps, le serveur est inactif avec une utilisation de 5 %. Cependant, lorsque Westlife se reforme (et ils le feront) et lance la vente de billets pour leur nouvelle tournée, le serveur de Ticket Master devient surchargé alors que tous les anciens adolescents, désormais trentenaires aisés, tentent de se connecter et d’acheter des billets en même temps. [Remplacez Westlife par le lancement de l’iPhoneX si cela est plus parlant pour vous].
L’Auto-Scaling arrive alors à la rescousse – également souvent appelé calcul élastique. Si le serveur Tick Master a été créé à l’aide de la fonctionnalité d’auto-scaling de K5, alors lorsque la charge du serveur commence à augmenter et dépasse un seuil prédéfini, K5 construit automatiquement un nouveau serveur et l’ajoute à votre pool d’instances équilibrées de charge – et tout cela sans aucun effort de votre part.
Et cela devient encore meilleur : une fois que tout le monde a ses billets et que les serveurs équilibrés de charge ne sont plus fortement sollicités, K5 réduit à nouveau l’infrastructure pour qu’elle corresponde à la demande actuelle – automatiquement.
Cela semble être beaucoup de travail – la bonne nouvelle est que K5 a déjà amélioré HEAT et utilise le Ceilometer OpenStack de K5 pour effectuer tout ce travail pour vous – ces améliorations sont documentées dans le Guide Heat de K5 qui se trouve ici.
Vous n’avez qu’à configurer et déployer une pile heat telle que celle-ci :
Ce fichier contient des caractères Unicode cachés ou bidirectionnels qui peuvent être interprétés ou compilés différemment de ce qui est affiché ci-dessous. Pour les examiner, ouvrez le fichier dans un éditeur qui révèle les caractères Unicode cachés.
En savoir plus sur les caractères Unicode bidirectionnels
Afficher les caractères cachés
| # Modèle K5 de base pour démontrer les améliorations d'AutoScaling HEAT de Fujitsu | |
| # Auteur : Graham J Land | |
| # Date : 10/10/2017 | |
| heat_template_version: 2013-05-23 | |
| description: | |
| Modèle d'exemple d'AutoScaling IaaS Fujitsu Cloud Service K5. | |
| # Les prérequis pour un déploiement réussi | |
| parameters: | |
| # zone de disponibilité cible | |
| az: | |
| type: string | |
| default: uk-1b | |
| # serveur à mettre à l'échelle – application nodejs simple dans cette démo | |
| param_image_id: | |
| type: string | |
| default: bc4d2c64-1694-4488-80e2-e089bd18fc42 | |
| # taille de serveur à utiliser | |
| param_flavor: | |
| type: string | |
| default: S-1 | |
| # clés ssh à injecter dans les serveurs mis à l'échelle | |
| key_name: | |
| type: string | |
| description: Clé SSH pour se connecter aux serveurs | |
| default: LEMP-KP-AZ2 | |
| # routeur existant dans le projet avec passerelle externe configurée | |
| autoscale_router: | |
| type: string | |
| default: 5b29b682-df94-4178-b1b4-9bf487055787 | |
| # ce qui est réellement construit | |
| resources: | |
| # créer un réseau privé | |
| autoscale_private_net_az: | |
| type: OS::Neutron::Net | |
| properties: | |
| availability_zone: { get_param: az } | |
| name: "autoscale_private_net" | |
| # créer un nouveau sous-réseau sur le privé ci-dessus | |
| autoscale_private_subnet_az: | |
| type: OS::Neutron::Subnet | |
| depends_on: autoscale_private_net_az | |
| properties: | |
| availability_zone: { get_param: az } | |
| name: "autoscale_private_subnet_az" | |
| network_id: { get_resource: autoscale_private_net_az } | |
| cidr: "192.168.200.0/24" | |
| gateway_ip: "192.168.200.254" | |
| allocation_pools: | |
| – start: "192.168.200.100" | |
| end: "192.168.200.150" | |
| dns_nameservers: ["62.60.42.9", "62.60.42.10"] | |
| # connecter une interface sur le sous-réseau du réseau au routeur existant | |
| az_router_interface: | |
| type: OS::Neutron::RouterInterface | |
| depends_on: [autoscale_private_subnet_az] | |
| properties: | |
| router_id: { get_param: autoscale_router } | |
| subnet_id: { get_resource: autoscale_private_subnet_az } | |
| # créer un nouveau groupe de sécurité pour l'accès de votre PC | |
| # faites simplement une recherche Google "what's my ip" pour déterminer votre adresse NAT publique | |
| # la mienne était 31.53.253.24 pendant la démo ci-dessous | |
| security_group_01: | |
| type: OS::Neutron::SecurityGroup | |
| properties: | |
| description: Ajouter des règles de groupe de sécurité pour le serveur | |
| name: AutoScaleServer | |
| rules: | |
| # autoriser la connexion ssh (port 22) depuis mon pc | |
| – remote_ip_prefix: 31.53.253.24/32 | |
| protocol: tcp | |
| port_range_min: 22 | |
| port_range_max: 22 | |
| # autoriser les paquets ping depuis mon pc | |
| – remote_ip_prefix: 31.53.253.24/32 | |
| protocol: icmp | |
| # créer un groupe de sécurité ouvert pour que tout le monde puisse accéder au LBaaS public | |
| security_group_02: | |
| type: OS::Neutron::SecurityGroup | |
| properties: | |
| description: Ajouter des règles de groupe de sécurité pour le serveur | |
| name: AutoScaleLBaaS | |
| rules: | |
| # autoriser le trafic http (port 80) de 'tout l'internet' | |
| – remote_ip_prefix: 0.0.0.0/0 | |
| protocol: tcp | |
| port_range_min: 80 | |
| port_range_max: 80 | |
| # définir le pool de serveurs de mise à l'échelle | |
| web_server_group: | |
| depends_on: [ az_router_interface ] | |
| type: FCX::AutoScaling::AutoScalingGroup | |
| properties: | |
| AvailabilityZones: [{get_param: az}] | |
| LaunchConfigurationName: {get_resource: launch_config} | |
| MinSize: '1' | |
| MaxSize: '3' | |
| VPCZoneIdentifier: [ {get_resource: autoscale_private_subnet_az} ] | |
| LoadBalancerNames: [ {get_resource: eLBint} ] | |
| # c'est l'unité de déploiement réellement scalable – le serveur web | |
| launch_config: | |
| type: FCX::AutoScaling::LaunchConfiguration | |
| depends_on: [ security_group_01, az_router_interface ] | |
| properties: | |
| ImageId: { get_param: param_image_id } | |
| InstanceType: { get_param: param_flavor } | |
| KeyName: {get_param: key_name} | |
| SecurityGroups: [ {get_resource: security_group_01}, {get_resource: security_group_02} ] | |
| BlockDeviceMappingsV2: [{source_type: 'image', destination_type: 'volume', boot_index: '0', device_name: '/dev/vda', volume_size: '3',uuid: {get_param: param_image_id}, delete_on_termination: true}] | |
| UserData: | |
| #!/bin/bash | |
sudo hostname hostname |
|
| echo "Rebooting Hack" | |
| sudo reboot | |
| # créer l'équilibreur de charge qui sera utilisé pour | |
| # gérer les instances de mise à l'échelle | |
| eLBint: | |
| type: FJ::ExpandableLoadBalancer::LoadBalancer | |
| depends_on: [ security_group_01, az_router_interface ] | |
| properties: | |
| Subnets: [ {get_resource: autoscale_private_subnet_az} ] | |
| Listeners: | |
| – {LoadBalancerPort: '80', InstancePort: '80', Protocol: 'HTTP', InstanceProtocol: 'HTTP' } | |
| HealthCheck: {Target: 'HTTP:80/', HealthyThreshold: '2', UnhealthyThreshold: '3', Interval: '5', Timeout: '5'} | |
| Version: 2014-09-30 | |
| Scheme: public | |
| LoadBalancerName: autoscaler | |
| SecurityGroups: [ {get_resource: security_group_02} ] | |
| # créer la politique de mise à l'échelle vers le haut | |
| web_server_scaleout_policy: | |
| type: FCX::AutoScaling::ScalingPolicy | |
| properties: | |
| AdjustmentType: ChangeInCapacity | |
| AutoScalingGroupName: {get_resource: web_server_group} | |
| Cooldown: '10' | |
| ScalingAdjustment: '1' | |
| # créer la politique de mise à l'échelle vers le bas | |
| web_server_scalein_policy: | |
| type: FCX::AutoScaling::ScalingPolicy | |
| properties: | |
| AdjustmentType: ChangeInCapacity | |
| AutoScalingGroupName: {get_resource: web_server_group} | |
| Cooldown: '10' | |
| ScalingAdjustment: '-1' | |
| # créer l'événement ALARM qui se déclenche lorsque | |
| # le serveur est surchargé | |
| cpu_alarm_high: | |
| type: OS::Ceilometer::Alarm | |
| properties: | |
| description: Scale-out si le CPU moyen > 50% pendant 1 minute | |
| meter_name: fcx.compute.cpu_util | |
| statistic: avg | |
| period: '60' | |
| evaluation_periods: '1' | |
| threshold: '50' | |
| alarm_actions: | |
| – {get_attr: [web_server_scaleout_policy, AlarmUrl]} | |
| matching_metadata: {'metadata.user_metadata.groupname': {get_resource: web_server_group}} | |
| comparison_operator: gt | |
| # créer l'événement ALARM 'reset' lorsque les services reviennent à la normale | |
| # charges de travail | |
| cpu_alarm_low: | |
| type: OS::Ceilometer::Alarm | |
| properties: | |
| description: Scale-in si le CPU moyen < 15% pendant 1 minute | |
| meter_name: fcx.compute.cpu_util | |
| statistic: avg | |
| period: '60' | |
| evaluation_periods: '1' | |
| threshold: '15' | |
| alarm_actions: | |
| – {get_attr: [web_server_scalein_policy, AlarmUrl]} | |
| matching_metadata: {'metadata.user_metadata.groupname': {get_resource: web_server_group}} | |
| comparison_operator: lt | |
voir le code brut
K5AutoScaling.yml
hébergé avec ❤ par GitHub
Essayons cela maintenant –
Prérequis du modèle :
az : Entrez la zone de disponibilité cible, dans mon cas uk-1b
param_image_id :
Si vous n’avez pas votre propre serveur pour tester, l’image de build que j’utilise est un simple serveur Ubuntu sur lequel Nodejs est installé avec l’application suivante /var/helloworld/helloworld.js (n’oubliez pas de faire « npm install –save express) –
Ce fichier contient des caractères Unicode cachés ou bidirectionnels qui peuvent être interprétés ou compilés différemment de ce qui est affiché ci-dessous. Pour les examiner, ouvrez le fichier dans un éditeur qui révèle les caractères Unicode cachés.
En savoir plus sur les caractères Unicode bidirectionnels
Afficher les caractères cachés
| const express = require('express') | |
| const app = express() | |
| const serverName = require('os').hostname(); | |
| const messageTop = ' \ |
|
Hello from ' |
|
| const messageTail = '\ | |
\ |
|
| \ | |
| ' | |
| app.get('/', function (req, res) { | |
| res.send(messageTop + serverName + messageTail) | |
| }) | |
| app.listen(80, function () { | |
| console.log('Example app listening on port 80') | |
| }) |
voir le code brut
helloworld.js
hébergé avec ❤ par GitHub
Pour exécuter cette application en tant que service sur Ubuntu, copiez le fichier helloworld.conf suivant dans /etc/init sur le serveur. Assurez-vous d’ajuster le nom de fichier et le chemin dans le fichier ci-dessous pour qu’ils correspondent au nom et à l’emplacement où vous avez stocké le fichier ci-dessus –
Ce fichier contient des caractères Unicode cachés ou bidirectionnels qui peuvent être interprétés ou compilés différemment de ce qui est affiché ci-dessous. Pour les examiner, ouvrez le fichier dans un éditeur qui révèle les caractères Unicode cachés.
En savoir plus sur les caractères Unicode bidirectionnels
Afficher les caractères cachés
| description "Fujitsu K5 IaaS AutoScaling Demo Node.js Server" | |
| author "Graham J Land" | |
| start on started mountall | |
| stop on shutdown | |
| respawn | |
| respawn limit 99 5 | |
| script | |
| export HOME="/root" | |
| exec /usr//bin/nodejs /var/helloworld/helloworld.js >> /var/log/node.log 2>&1 | |
| end script | |
| post-start script | |
| echo "Started HelloWorld Demo NodeJS Webserver" | |
| end script |
voir le code brut
helloworld.conf
hébergé avec ❤ par GitHub
param_flavor : taille de serveur en « t-shirt », S-1
key_name : votre clé ssh publique, j’ai utilisé LEMP-KP-AZ2
autoscale_router : il s’agit de l’id d’un routeur existant dans votre projet qui a une passerelle externe configurée.
Lancement du modèle :
Une fois que vous avez satisfait les prérequis ci-dessus et modifié le modèle avec votre configuration locale, il est temps de déployer notre infrastructure. J’utiliserai le portail K5 dans l’exemple ici, mais vous pouvez également utiliser les API natives de K5 ou même le client openstack.
Regardez le film – gratuitement ici – pour voir comment tout s’assemble.
Bonne création de piles !
Graham.
Originally published on allthingscloud.eu (2017-10-10).