Auto-Scaling Infrastructure as Code – Calcolo Elastico su K5 IaaS
2017-10-10
Machine-translated — the English original is authoritative.
Nell'articolo di oggi esamineremo come distribuire e testare la funzione di AutoScaling di Fujitsu K5 IaaS.
Panoramica
Cosa intendo quindi con la funzione di auto-scaling di K5? Beh, immaginate di avere un server virtuale che presenta picchi e cali di domanda. Prendete l'esempio del webserver di Ticket Master: per il 99% del tempo il server rimane lì inattivo al 5% di utilizzo. Tuttavia, quando Westlife si ricompone (e lo faranno) e lancia le vendite dei biglietti per il loro nuovo tour, il server di Ticket Master va in sovraccarico mentre tutti gli ex adolescenti, ora trentenni ricchi di denaro, provano ad accedere e acquistare biglietti contemporaneamente. [Sostituite Westlife con il lancio dell'iPhoneX se questo ha più senso per voi].
Arriva in soccorso l'Auto-Scaling – spesso definito anche come calcolo elastico. Se il server Tick Master è stato creato utilizzando la funzione di autoscaling di K5, quando il carico sul server inizia a salire e supera una soglia predefinita, K5 crea automaticamente un nuovo server e lo aggiunge al vostro pool di istanze bilanciate del carico – tutto questo senza alcun vostro sforzo.
E la cosa diventa ancora migliore: una volta che tutti hanno ottenuto i loro biglietti e i server bilanciatori del carico non sono più fortemente utilizzati, K5 ridurrà nuovamente l'infrastruttura per adattarla alla domanda corrente – automaticamente.
Sembra un sacco di lavoro – la buona notizia è che K5 ha già potenziato HEAT e sfrutta Ceilometer di K5 OpenStack per fare tutto questo lavoro per voi – questi miglioramenti sono documentati nella Guida Heat di K5, che si trova qui.
Tutto ciò che dovete fare è configurare e distribuire uno stack heat come questo:
Questo file contiene caratteri Unicode nascosti o bidirezionali che potrebbero essere interpretati o compilati in modo diverso da quanto appare di seguito. Per rivederli, aprire il file in un editor che riveli i caratteri Unicode nascosti.
Maggiori informazioni sui caratteri Unicode bidirezionali
| # Modello base K5 per dimostrare i miglioramenti di HEAT Autoscaling di Fujitsu | |
| # Autore: Graham J Land | |
| # Data: 10/10/2017 | |
| heat_template_version: 2013-05-23 | |
| description: | |
| Modello di esempio per l'AutoScaling IaaS di Fujitsu Cloud Service K5. | |
| # I prerequisiti per una distribuzione di successo | |
| parameters: | |
| # zona di disponibilità target | |
| az: | |
| type: string | |
| default: uk-1b | |
| # server da scalare – semplice app nodejs in questa demo | |
| param_image_id: | |
| type: string | |
| default: bc4d2c64-1694-4488-80e2-e089bd18fc42 | |
| # taglia di server da utilizzare | |
| param_flavor: | |
| type: string | |
| default: S-1 | |
| # chiavi ssh da iniettare nei server scalati | |
| key_name: | |
| type: string | |
| description: Chiave SSH per connettersi ai server | |
| default: LEMP-KP-AZ2 | |
| # router esistente nel progetto con gateway esterno configurato | |
| autoscale_router: | |
| type: string | |
| default: 5b29b682-df94-4178-b1b4-9bf487055787 | |
| # ciò che viene effettivamente creato | |
| resources: | |
| # crea una rete privata | |
| autoscale_private_net_az: | |
| type: OS::Neutron::Net | |
| properties: | |
| availability_zone: { get_param: az } | |
| name: "autoscale_private_net" | |
| # crea un nuovo subnet sulla rete privata sopra | |
| 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"] | |
| # connette un'interfaccia sulla subnet della rete al router esistente | |
| 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 } | |
| # crea un nuovo gruppo di sicurezza per l'accesso del tuo PC | |
| # basta cercare su google "what's my ip" per determinare il tuo indirizzo NAT pubblico | |
| # il mio era 31.53.253.24 durante la demo qui sotto | |
| security_group_01: | |
| type: OS::Neutron::SecurityGroup | |
| properties: | |
| description: Aggiungi regole del gruppo di sicurezza per il server | |
| name: AutoScaleServer | |
| rules: | |
| # consenti connessione ssh (porta 22) dal mio pc | |
| – remote_ip_prefix: 31.53.253.24/32 | |
| protocol: tcp | |
| port_range_min: 22 | |
| port_range_max: 22 | |
| # consenti pacchetti ping dal mio pc | |
| – remote_ip_prefix: 31.53.253.24/32 | |
| protocol: icmp | |
| # crea un gruppo di sicurezza aperto per consentire a tutti di accedere al pubblico LBaaS | |
| security_group_02: | |
| type: OS::Neutron::SecurityGroup | |
| properties: | |
| description: Aggiungi regole del gruppo di sicurezza per il server | |
| name: AutoScaleLBaaS | |
| rules: | |
| # consenti traffico http (porta 80) da 'tutto internet' | |
| – remote_ip_prefix: 0.0.0.0/0 | |
| protocol: tcp | |
| port_range_min: 80 | |
| port_range_max: 80 | |
| # definisci il pool di server di scaling | |
| 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} ] | |
| # questa è l'unità effettiva di distribuzione scalabile – il server 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 | |
| # crea il bilanciatore del carico che verrà utilizzato per | |
| # gestire le istanze di scaling | |
| 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} ] | |
| # crea la politica di scale out | |
| web_server_scaleout_policy: | |
| type: FCX::AutoScaling::ScalingPolicy | |
| properties: | |
| AdjustmentType: ChangeInCapacity | |
| AutoScalingGroupName: {get_resource: web_server_group} | |
| Cooldown: '10' | |
| ScalingAdjustment: '1' | |
| # crea la politica di scale in | |
| web_server_scalein_policy: | |
| type: FCX::AutoScaling::ScalingPolicy | |
| properties: | |
| AdjustmentType: ChangeInCapacity | |
| AutoScalingGroupName: {get_resource: web_server_group} | |
| Cooldown: '10' | |
| ScalingAdjustment: '-1' | |
| # crea l'evento ALARM che si attiva quando | |
| # il server è sovraccarico | |
| cpu_alarm_high: | |
| type: OS::Ceilometer::Alarm | |
| properties: | |
| description: Scale-out se la CPU media > 50% per 1 minuto | |
| 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 | |
| # crea l'evento ALARM 'reset' quando i servizi tornano alla normalità | |
| # carichi di lavoro | |
| cpu_alarm_low: | |
| type: OS::Ceilometer::Alarm | |
| properties: | |
| description: Scale-in se la CPU media < 15% per 1 minuto | |
| 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 | |
visualizza raw
K5AutoScaling.yml
ospitato con ❤ da GitHub
Proviamo ora questo –
Prerequisiti del modello:
az: Inserisci la zona di disponibilità target, nel mio caso uk-1b
param_image_id:
Se non hai un tuo server da testare, l'immagine di build che sto utilizzando è un semplice server Ubuntu con Nodejs installato e la seguente applicazione /var/helloworld/helloworld.js (non dimenticare di eseguire "npm install –save express") –
Questo file contiene caratteri Unicode nascosti o bidirezionali che potrebbero essere interpretati o compilati in modo diverso da quanto appare di seguito. Per rivederli, aprire il file in un editor che riveli i caratteri Unicode nascosti.
Maggiori informazioni sui caratteri Unicode bidirezionali
| const express = require('express') | |
| const app = express() | |
| const serverName = require('os').hostname(); | |
| const messageTop = ' \ |
|
Ciao da ' |
|
| const messageTail = '\ | |
\ |
|
| \ | |
| ' | |
| app.get('/', function (req, res) { | |
| res.send(messageTop + serverName + messageTail) | |
| }) | |
| app.listen(80, function () { | |
| console.log('Example app listening on port 80') | |
| }) |
visualizza raw
helloworld.js
ospitato con ❤ da GitHub
Per eseguire questa applicazione come servizio su Ubuntu, copia il seguente file helloworld.conf in /etc/init sul server. Assicurati di regolare il nome del file e il percorso nel file sottostante in modo che corrispondano sia al nome che alla posizione in cui hai memorizzato il file sopra –
Questo file contiene caratteri Unicode nascosti o bidirezionali che potrebbero essere interpretati o compilati in modo diverso da quanto appare di seguito. Per rivederli, aprire il file in un editor che riveli i caratteri Unicode nascosti.
Maggiori informazioni sui caratteri Unicode bidirezionali
| 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 |
visualizza raw
helloworld.conf
ospitato con ❤ da GitHub
param_flavor: taglia del server, S-1
key_name: la tua chiave ssh pubblica, ho usato LEMP-KP-AZ2
autoscale_router: questo è l'ID di un router esistente nel tuo progetto che ha un gateway esterno configurato.
Lancio del modello:
Una volta soddisfatti i prerequisiti sopra e modificato il modello con la tua configurazione locale, è il momento di distribuire la nostra infrastruttura. Userò il portale K5 nell'esempio qui, ma potresti anche utilizzare le API native di K5 o persino il client openstack.
Guarda il filmato – gratuitamente qui – per vedere come tutto si unisce.
Happy Stacking!
Graham.
Originally published on allthingscloud.eu (2017-10-10).