Skalieren¶

Erstellen Sie mehr Aufgaben¶

Verwenden Sie SSH mit dem vorhandenen SSH-Schlüsselpaar, um sich an dem app-controller Controller-Instanz anzumelden.

$ ssh -i ~/.ssh/id_rsa USERNAME@IP_CONTROLLER

Rufen Sie den faafo Befehlszeilenschnittstelle an, um die Erzeugung von fünf großen Fraktalen anzufordern.

$ faafo create --height 9999 --width 9999 --tasks 5

Wenn Sie die Belastung des Workers überprüfen, können Sie sehen, dass die Instanz nicht gut läuft. Bei der einzelnen CPU-Varianten-Instanz bedeutet ein Last-Durchschnitt größer als 1, dass der Server an der Kapazitätsgrenze ist.

$ ssh -i ~/.ssh/id_rsa USERNAME@IP_WORKER uptime
10:37:39 up  1:44,  2 users,  load average: 1.24, 1.40, 1.36

Erstellen Sie weitere API-Dienstanforderungen¶

API Last ist ein etwas anderes Problem als die vorherige in Bezug auf die Fähigkeit zu arbeiten. Wir können viele Anfragen an die API simulieren, wie folgt:

Verwenden Sie SSH mit dem vorhandenen SSH-Schlüsselpaar, um sich an dem app-controller Controller-Instanz anzumelden.

$ ssh -i ~/.ssh/id_rsa USERNAME@IP_CONTROLLER

Verwenden Sie eine for-Schleife, um den faafo-Befehlszeilen-Interface anzurufen, um einen zufälligen Satz von Fraktalen 500 mal anzufordern:

$ for i in $(seq 1 500); do faafo --endpoint-url http://IP_CONTROLLER create & done

Wenn Sie die Belastung auf dem app-controller API Service Instanz überprüfen, sehen Sie, dass die Instanz nicht gut läuft. Bei Ihrer einzelnen CPU-Varianten-Instanz bedeutet ein Last-Durchschnitt größer als 1, dass der Server an Kapazität ist.

$ uptime
10:37:39 up  1:44,  2 users,  load average: 1.24, 1.40, 1.36

Die schiere Anzahl von Anfragen bedeutet, dass einige Anfragen für Fraktale es nicht zur Nachrichtenwarteschlange zur Verarbeitung machen können. Um sicherzustellen, dass Sie mit der Nachfrage fertig werden können, müssen Sie auch die API-Fähigkeit der Fractals-Anwendung skalieren.

Entfernen Sie die vorhandene App¶

Gehen Sie vor und löschen Sie die vorhandenen Instanzen und Sicherheitsgruppen, die Sie in früheren Abschnitten erstellt haben. Denken Sie daran, wenn Instanzen in der Cloud nicht mehr arbeiten, entfernen Sie sie und erstellen Sie etwas neu.

for instance in conn.list_servers():
    if instance.name in ['all-in-one','app-worker-1', 'app-worker-2', 'app-controller']:
        print('Destroying Instance: %s' % instance.name)
        conn.delete_server(instance.id, wait=True)

for group in conn.list_security_groups():
    if group['name'] in ['control', 'worker', 'api', 'services']:
        print('Deleting security group: %s' % group['name'])
        conn.delete_security_group(group['name'])

Zusätzliche Sicherheitsgruppen¶

Wenn Sie die Topologie Ihrer Anwendungen ändern, müssen Sie Sicherheitsgruppen aktualisieren oder erstellen. Hier erstellen Sie die erforderlichen Sicherheitsgruppen neu.

api_group = conn.create_security_group('api', 'for API services only')
conn.create_security_group_rule(api_group['name'], 80, 80, 'TCP')
conn.create_security_group_rule(api_group['name'], 22, 22, 'TCP')

worker_group = conn.create_security_group('worker', 'for services that run on a worker node')
conn.create_security_group_rule(worker_group['name'], 22, 22, 'TCP')

services_group = conn.create_security_group('services', 'for DB and AMQP services only')
conn.create_security_group_rule(services_group['name'], 22, 22, 'TCP')
conn.create_security_group_rule(services_group['name'], 3306, 3306, 'TCP', remote_group_id=api_group['id'])
conn.create_security_group_rule(services_group['name'], 5672, 5672, 'TCP', remote_group_id=worker_group['id'])
conn.create_security_group_rule(services_group['name'], 5672, 5672, 'TCP', remote_group_id=api_group['id'])

Eine Floating-IP-Helferfunktion¶

Definieren Sie eine kurze Funktion, um unbenutzte oder zugängliche Floating-IPs zu lokalisieren. Das spart ein paar Zeilen Code und verhindert, dass Sie Ihr Floating-IP-Quota zu schnell erreichen.

def get_floating_ip(conn):
    '''A helper function to re-use available Floating IPs'''
    return conn.available_floating_ip()

Teilen Sie die Datenbank und die Nachrichtenwarteschlange¶

Bevor Sie Ihre Anwendungsdienste ausschalten, wie der API-Dienst oder die Mitarbeiter, müssen Sie eine zentrale Datenbank und einen Code hinzufügen: app-services Messaging-Instanz. Die Datenbank- und Messaging-Warteschlange wird verwendet, um den Zustand der Fraktale zu verfolgen und die Kommunikation zwischen den Diensten zu koordinieren.

userdata = '''#!/usr/bin/env bash
curl -L -s https://opendev.org/openstack/faafo/raw/contrib/install.sh | bash -s -- \
    -i database -i messaging
'''

instance_services = conn.create_server(wait=True, auto_ip=False,
    name='app-services',
    image=image_id,
    flavor=flavor_id,
    key_name='demokey',
    security_groups=[services_group['name']],
    userdata=userdata)

services_ip = conn.get_server_private_ip(instance_services)

Skalieren Sie den API-Dienst¶

Mit mehreren Workern, die Fraktale erzegen so schnell wie sie können, muss das System in der Lage sein, die Anfragen für Fraktale so schnell wie möglich zu erhalten. Wenn unsere Anwendung populär wird, können viele Tausende von Benutzern eine Verbindung zu unserer API herstellen, um Fraktale zu erzeugen.

Bewaffnet mit einer Sicherheitsgruppe, Abbild und Varianten-Größe, können Sie mehrere API-Dienste hinzufügen:

userdata = '''#!/usr/bin/env bash
curl -L -s https://opendev.org/openstack/faafo/raw/contrib/install.sh | bash -s -- \
    -i faafo -r api -m 'amqp://guest:guest@%(services_ip)s:5672/' \
    -d 'mysql+pymysql://faafo:password@%(services_ip)s:3306/faafo'
''' % { 'services_ip': services_ip }

instance_api_1 = conn.create_server(wait=True, auto_ip=False,
    name='app-api-1',
    image=image_id,
    flavor=flavor_id,
    key_name='demokey',
    security_groups=[api_group['name']],
    userdata=userdata)
instance_api_2 = conn.create_server(wait=True, auto_ip=False,
    name='app-api-2',
    image=image_id,
    flavor=flavor_id,
    key_name='demokey',
    security_groups=[api_group['name']],
    userdata=userdata)

api_1_ip = conn.get_server_private_ip(instance_api_1)
api_2_ip = conn.get_server_private_ip(instance_api_2)

for instance in [instance_api_1,  instance_api_2]:
    floating_ip = get_floating_ip(conn)
    conn.add_ip_list(instance, [floating_ip['floating_ip_address']])
    print('allocated %(ip)s to %(host)s' % {'ip': floating_ip['floating_ip_address'], 'host': instance['name']})

Diese Dienste sind kundenorientiert, so dass sie im Gegensatz zu den Mitarbeitern keine Nachrichtenwarteschlange verwenden, um Aufgaben zu verteilen. Stattdessen müssen Sie eine Art Lastverteilungsmechanismus einführen, um eingehende Anfragen zwischen den verschiedenen API-Diensten zu teilen.

Eine einfache Lösung ist, die Hälfte Ihrer Freunde eine Adresse und die Hälfte der anderen zu geben, aber diese Lösung ist nicht nachhaltig. Stattdessen können Sie ein ‚DNS Round Robin‘ benutzen <http://en.wikipedia.org/wiki/Round- robin_DNS> _, um das automatisch zu tun. Allerdings kann OpenStack Networking Load Balancing als Service bieten, was :doc:/networking` erklärt.

Skalieren Sie die Worker¶

Um die Gesamtkapazität zu erhöhen, fügen Sie drei Worker hinzu:

userdata = '''#!/usr/bin/env bash
curl -L -s https://opendev.org/openstack/faafo/raw/contrib/install.sh | bash -s -- \
    -i faafo -r worker -e 'http://%(api_1_ip)s' -m 'amqp://guest:guest@%(services_ip)s:5672/'
''' % {'api_1_ip': api_1_ip, 'services_ip': services_ip}

instance_worker_1 = conn.create_server(wait=True, auto_ip=False,
    name='app-worker-1',
    image=image_id,
    flavor=flavor_id,
    key_name='demokey',
    security_groups=[worker_group['name']],
    userdata=userdata)

instance_worker_2 = conn.create_server(wait=True, auto_ip=False,
    name='app-worker-2',
    image=image_id,
    flavor=flavor_id,
    key_name='demokey',
    security_groups=[worker_group['name']],
    userdata=userdata)

instance_worker_3 = conn.create_server(wait=True, auto_ip=False,
    name='app-worker-3',
    image=image_id,
    flavor=flavor_id,
    key_name='demokey',
    security_groups=[worker_group['name']],
    userdata=userdata)

Wenn Sie diese Kapazität hinzufügen, können Sie mit einer höheren Anzahl von Anträgen auf Fraktale umgehen. Sobald diese Worker-Instanzen beginnen, beginnen sie mit der Überprüfung der Message-Queue für Anfragen, wodurch der Gesamt-Backlog wie eine neue Kasseneröffnung im Supermarkt reduziert wird.

Dieser Vorgang war offensichtlich ein sehr manueller. Herauszufinden, dass wir mehr Worker brauchten und diese dann zu starten, bedarf einiger Anstrengungen. Idealerweise würde das System das selbst tun. Wenn Sie Ihre Anwendung aufbauen, um diese Situationen zu erkennen, können Sie sie automatisch Ressourcen anfordern und entfernen, was Ihnen Mühe macht ist, diese Arbeit selbst zu tun. Stattdessen kann der OpenStack Orchestrierungsdienst die Last überwachen und Instanzen starten. Um herauszufinden, wie man das einrichtet, siehe Orchestrierung.