Auto-escalado de Infraestructura como Código – Computación Elástica en K5 IaaS

2017-10-10

Auto-escalado de Infraestructura como Código – Computación Elástica en K5 IaaS

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

Mostrar caracteres ocultos

# 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

Mostrar caracteres ocultos

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')
})

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

Mostrar caracteres ocultos

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.

Contenido incrustado

¡Feliz Apilamiento!

Graham.

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

← All posts