Auto-escalado de Infraestructura como Código – Computación Elástica en K5 IaaS
2017-10-10
Machine-translated — the English original is authoritative.
En el artículo de hoy, recorreremos cómo implementar y probar la función de Autoescalado de Fujitsu K5 IaaS.
Resumen
Bueno, ¿a qué me refiero con la función de autoescalado de K5? Bueno, imagina que tienes un servidor virtual que tiene picos y valles en la demanda. Toma el ejemplo del servidor web de Ticket Master, el 99% del tiempo el servidor está allí inactivo al 5% de utilización. Sin embargo, cuando Westlife se reagrupa (y lo harán) y lanzan las ventas de entradas para su nueva gira, el servidor de Ticket Master se sobrecarga mientras todos los antiguos adolescentes, ahora treintañeros con dinero, intentan iniciar sesión y comprar entradas al mismo tiempo. [Reemplaza Westlife con el lanzamiento del iPhoneX si eso tiene más sentido para ti].
Llega el Autoescalado al rescate, también conocido a menudo como computación elástica. Si el servidor Tick Master se creó utilizando la función de autoescalado de K5, cuando la carga en el servidor comienza a subir y cruza un umbral predefinido, K5 construye mágicamente un nuevo servidor y lo agrega a tu grupo de instancias con balanceo de carga, todo con cero esfuerzo por tu parte.
Y aún es mejor, una vez que todos tienen sus entradas y los servidores con balanceo de carga ya no están altamente utilizados, K5 volverá a reducir la infraestructura para coincidir con la demanda actual, automáticamente.
Suena como mucho trabajo, pero la buena noticia es que K5 ya ha mejorado HEAT y aprovecha el Ceilometer de OpenStack de K5 para hacer todo este trabajo por ti, estas mejoras están documentadas en la Guía de Heat de K5 que se encuentra aquí.
Todo lo que necesitas hacer es configurar e implementar una pila de heat como esta:
Este archivo contiene texto Unicode oculto o bidireccional que puede ser interpretado o compilado de manera diferente a lo que aparece a continuación. Para revisarlo, abre el archivo en un editor que revele caracteres Unicode ocultos.
Más información sobre caracteres Unicode bidireccionales
| # Plantilla básica de K5 para demostrar las mejoras de Autoescalado HEAT de Fujitsu | |
| # Autor: Graham J Land | |
| # Fecha: 10/10/2017 | |
| heat_template_version: 2013-05-23 | |
| description: | |
| Plantilla de ejemplo de Autoescalado IaaS Fujitsu Cloud Service K5. | |
| # Los prerrequisitos para una implementación exitosa | |
| parameters: | |
| # zona de disponibilidad objetivo | |
| az: | |
| type: string | |
| default: uk-1b | |
| # servidor a escalar – aplicación simple nodejs en esta demostración | |
| param_image_id: | |
| type: string | |
| default: bc4d2c64-1694-4488-80e2-e089bd18fc42 | |
| # tamaño de camiseta a usar | |
| param_flavor: | |
| type: string | |
| default: S-1 | |
| # claves ssh que se inyectarán en los servidores escalados | |
| key_name: | |
| type: string | |
| description: Clave SSH para conectarse a los servidores | |
| default: LEMP-KP-AZ2 | |
| # enrutador existente en el proyecto con puerta de enlace externa configurada | |
| autoscale_router: | |
| type: string | |
| default: 5b29b682-df94-4178-b1b4-9bf487055787 | |
| # lo que realmente se construye | |
| resources: | |
| # crear una red privada | |
| autoscale_private_net_az: | |
| type: OS::Neutron::Net | |
| properties: | |
| availability_zone: { get_param: az } | |
| name: "autoscale_private_net" | |
| # crear una nueva subred en la privada anterior | |
| 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"] | |
| # conectar una interfaz en la subred de la red al enrutador existente | |
| 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 } | |
| # crear un nuevo grupo de seguridad para el acceso de tu PC | |
| # simplemente busca "what's my ip" para determinar tu dirección NAT pública | |
| # la mía era 31.53.253.24 durante la demostración a continuación | |
| security_group_01: | |
| type: OS::Neutron::SecurityGroup | |
| properties: | |
| description: Agregar reglas de grupo de seguridad para el servidor | |
| name: AutoScaleServer | |
| rules: | |
| # permitir conexión ssh (puerto 22) desde mi pc | |
| – remote_ip_prefix: 31.53.253.24/32 | |
| protocol: tcp | |
| port_range_min: 22 | |
| port_range_max: 22 | |
| # permitir paquetes ping desde mi pc | |
| – remote_ip_prefix: 31.53.253.24/32 | |
| protocol: icmp | |
| # crear grupo de seguridad abierto para que todos accedan al LBaaS público | |
| security_group_02: | |
| type: OS::Neutron::SecurityGroup | |
| properties: | |
| description: Agregar reglas de grupo de seguridad para el servidor | |
| name: AutoScaleLBaaS | |
| rules: | |
| # permitir tráfico http (puerto 80) desde 'toda internet' | |
| – remote_ip_prefix: 0.0.0.0/0 | |
| protocol: tcp | |
| port_range_min: 80 | |
| port_range_max: 80 | |
| # definir el grupo de servidores escalables | |
| 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} ] | |
| # esta es la unidad real escalable de implementación – el servidor 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 | |
| # crear el balanceador de carga que se utilizará para | |
| # gestionar las instancias escalables | |
| 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} ] | |
| # crear la política de escalado hacia afuera | |
| web_server_scaleout_policy: | |
| type: FCX::AutoScaling::ScalingPolicy | |
| properties: | |
| AdjustmentType: ChangeInCapacity | |
| AutoScalingGroupName: {get_resource: web_server_group} | |
| Cooldown: '10' | |
| ScalingAdjustment: '1' | |
| # crear la política de escalado hacia adentro | |
| web_server_scalein_policy: | |
| type: FCX::AutoScaling::ScalingPolicy | |
| properties: | |
| AdjustmentType: ChangeInCapacity | |
| AutoScalingGroupName: {get_resource: web_server_group} | |
| Cooldown: '10' | |
| ScalingAdjustment: '-1' | |
| # crear el evento ALARM que se activa cuando | |
| # el servidor está sobrecargado | |
| cpu_alarm_high: | |
| type: OS::Ceilometer::Alarm | |
| properties: | |
| description: Escalar hacia afuera si el CPU promedio > 50% durante 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 | |
| # crear el evento ALARM 'reset' cuando los servicios vuelven a la normalidad | |
| # cargas de trabajo | |
| cpu_alarm_low: | |
| type: OS::Ceilometer::Alarm | |
| properties: | |
| description: Escalar hacia adentro si el CPU promedio < 15% durante 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 | |
ver raw
K5AutoScaling.yml
alojado con ❤ por GitHub
Así que probemos esto ahora –
Prerrequisitos de la Plantilla:
az: Ingresa la zona de disponibilidad objetivo, en mi caso uk-1b
param_image_id:
Si no tienes tu propio servidor para probar, la imagen de compilación que estoy usando es un servidor Ubuntu simple que tiene Nodejs instalado con la siguiente aplicación /var/helloworld/helloworld.js (no olvides "npm install –save express") –
Este archivo contiene texto Unicode oculto o bidireccional que puede ser interpretado o compilado de manera diferente a lo que aparece a continuación. Para revisarlo, abre el archivo en un editor que revele caracteres Unicode ocultos.
Más información sobre caracteres Unicode bidireccionales
| 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') | |
| }) |
ver raw
helloworld.js
alojado con ❤ por GitHub
Para ejecutar esta aplicación como un servicio en Ubuntu, copia el siguiente archivo helloworld.conf a /etc/init en el servidor. Asegúrate de ajustar el nombre del archivo y la ruta en el archivo a continuación para que coincidan tanto con el nombre como con la ubicación donde guardaste el archivo anterior –
Este archivo contiene texto Unicode oculto o bidireccional que puede ser interpretado o compilado de manera diferente a lo que aparece a continuación. Para revisarlo, abre el archivo en un editor que revele caracteres Unicode ocultos.
Más información sobre caracteres Unicode bidireccionales
| 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 |
ver raw
helloworld.conf
alojado con ❤ por GitHub
param_flavor: tamaño de servidor de camiseta, S-1
key_name: tu clave ssh pública, he usado LEMP-KP-AZ2
autoscale_router: este es el id de un enrutador existente en tu proyecto que tiene una puerta de enlace externa configurada.
Plantilla de Lanzamiento:
Una vez que hayas satisfecho los prerrequisitos anteriores y modificado la plantilla con tu configuración local, es momento de implementar nuestra infraestructura. Usaré el portal K5 en el ejemplo aquí, sin embargo, también podrías usar las APIs nativas de K5 o incluso el cliente de openstack.
Mira la Película – gratis aquí – para ver cómo todo se une.
¡Feliz Apilamiento!
Graham.
Originally published on allthingscloud.eu (2017-10-10).