Auto-Scaling Infrastructure as Code – Calcul élastique sur K5 IaaS

2017-10-10

Auto-Scaling Infrastructure as Code – Calcul élastique sur K5 IaaS

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 = '
\
https://www.fujitsu.com/uk/Images/K5-climber-580x224_tcm23-2619235.jpg&quot; alt="K5 Autoscale">\

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.

Contenu intégré

Bonne création de piles !

Graham.

Originally published on allthingscloud.eu (2017-10-10).

← All posts