Wie stelle ich aktualisierte Docker-Images für Amazon ECS-Aufgaben bereit?

Registrierung einer neuen Aufgabe definition und Aktualisierung der Dienst für die neue Aufgabenstellung ist das empfohlene Konzept von AWS. Der einfachste Weg dies zu tun ist, um:

1. Navigieren Sie zu Task-Definitionen
2. Wählen Sie die richtige Aufgabe
3. Wählen Sie create new revision
4. Wenn man schon ziehen die neueste version der container-image mit so etwas wie den :aktuellen tag, dann klicken Sie einfach auf Erstellen. Andernfalls aktualisieren Sie die version-Nummer des Behälters Bild und klicken Sie dann auf Erstellen.
5. Erweitern Aktionen
6. Wählen Sie Update Service (zweimal)
7. Dann warten Sie, bis der Dienst neu gestartet werden

Dieses tutorial hat mehr detail und beschreibt, wie Sie die oben beschriebenen Schritte passen in eine end-zu-end-Produkt-Entwicklung Prozess.

Full disclosure: Dieses Lernprogramm verfügt über Container von Bitnami und ich arbeite für Bitnami. Aber die Gedanken, die hier geäußert sind meine eigenen und nicht die Meinung von Bitnami.

InformationsquelleAutor der Antwort Neal

Ich erstellt ein Skript für die Bereitstellung von aktualisierten Docker images auf eine staging-service ECS, so dass der entsprechende task definition bezieht sich auf die aktuellen Versionen der Docker-images. Ich weiß nicht, ob ich folgenden best practices, also feedback wäre willkommen.

Für das Skript zu arbeiten, benötigen Sie entweder ein Ersatzteil ECS-Instanz oder eine deploymentConfiguration.minimumHealthyPercent Wert, so dass ECS stehlen kann eine Instanz für die Bereitstellung des aktualisierten task-definition.

Mein Algorithmus ist wie folgt:

1. Tag Docker-images der entsprechenden Containern in der task-definition mit der Git-revision.
2. Schieben Sie das Andockfenster Bild-tags zu den entsprechenden Registern.
3. Abmelden alten task-Definitionen in der task-definition-Familie.
4. Registrieren Sie eine neue Aufgabendefinition, jetzt bezogen auf Docker images tagged mit aktuelle Git-Revisionen.
5. Update-service zu nutzen, neue Aufgabendefinition.

Meinen code eingefügt unter:

bereitstellen-ecs

#!/usr/bin/env python3
import subprocess
import sys
import os.path
import json
import re
import argparse
import tempfile

_root_dir = os.path.abspath(os.path.normpath(os.path.dirname(__file__)))
sys.path.insert(0, _root_dir)
from _common import *


def _run_ecs_command(args):
    run_command(['aws', 'ecs', ] + args)


def _get_ecs_output(args):
    return json.loads(run_command(['aws', 'ecs', ] + args, return_stdout=True))


def _tag_image(tag, qualified_image_name, purge):
    log_info('Tagging image \'{}\' as \'{}\'...'.format(
        qualified_image_name, tag))
    log_info('Pulling image from registry in order to tag...')
    run_command(
        ['docker', 'pull', qualified_image_name], capture_stdout=False)
    run_command(['docker', 'tag', '-f', qualified_image_name, '{}:{}'.format(
        qualified_image_name, tag), ])
    log_info('Pushing image tag to registry...')
    run_command(['docker', 'push', '{}:{}'.format(
        qualified_image_name, tag), ], capture_stdout=False)
    if purge:
        log_info('Deleting pulled image...')
        run_command(
            ['docker', 'rmi', '{}:latest'.format(qualified_image_name), ])
        run_command(
            ['docker', 'rmi', '{}:{}'.format(qualified_image_name, tag), ])


def _register_task_definition(task_definition_fpath, purge):
    with open(task_definition_fpath, 'rt') as f:
        task_definition = json.loads(f.read())

    task_family = task_definition['family']

    tag = run_command([
        'git', 'rev-parse', '--short', 'HEAD', ], return_stdout=True).strip()
    for container_def in task_definition['containerDefinitions']:
        image_name = container_def['image']
        _tag_image(tag, image_name, purge)
        container_def['image'] = '{}:{}'.format(image_name, tag)

    log_info('Finding existing task definitions of family \'{}\'...'.format(
        task_family
    ))
    existing_task_definitions = _get_ecs_output(['list-task-definitions', ])[
        'taskDefinitionArns']
    for existing_task_definition in [
        td for td in existing_task_definitions if re.match(
            r'arn:aws:ecs+:[^:]+:[^:]+:task-definition/{}:\d+'.format(
                task_family),
            td)]:
        log_info('Deregistering task definition \'{}\'...'.format(
            existing_task_definition))
        _run_ecs_command([
            'deregister-task-definition', '--task-definition',
            existing_task_definition, ])

    with tempfile.NamedTemporaryFile(mode='wt', suffix='.json') as f:
        task_def_str = json.dumps(task_definition)
        f.write(task_def_str)
        f.flush()
        log_info('Registering task definition...')
        result = _get_ecs_output([
            'register-task-definition',
            '--cli-input-json', 'file://{}'.format(f.name),
        ])

    return '{}:{}'.format(task_family, result['taskDefinition']['revision'])


def _update_service(service_fpath, task_def_name):
    with open(service_fpath, 'rt') as f:
        service_config = json.loads(f.read())
    services = _get_ecs_output(['list-services', ])[
        'serviceArns']
    for service in [s for s in services if re.match(
        r'arn:aws:ecs:[^:]+:[^:]+:service/{}'.format(
            service_config['serviceName']),
        s
    )]:
        log_info('Updating service with new task definition...')
        _run_ecs_command([
            'update-service', '--service', service,
            '--task-definition', task_def_name,
        ])


parser = argparse.ArgumentParser(
    description="""Deploy latest Docker image to staging server.
The task definition file is used as the task definition, whereas
the service file is used to configure the service.
""")
parser.add_argument(
    'task_definition_file', help='Your task definition JSON file')
parser.add_argument('service_file', help='Your service JSON file')
parser.add_argument(
    '--purge_image', action='store_true', default=False,
    help='Purge Docker image after tagging?')
args = parser.parse_args()

task_definition_file = os.path.abspath(args.task_definition_file)
service_file = os.path.abspath(args.service_file)

os.chdir(_root_dir)

task_def_name = _register_task_definition(
    task_definition_file, args.purge_image)
_update_service(service_file, task_def_name)

_common.py

import sys
import subprocess


__all__ = ['log_info', 'handle_error', 'run_command', ]


def log_info(msg):
    sys.stdout.write('* {}\n'.format(msg))
    sys.stdout.flush()


def handle_error(msg):
    sys.stderr.write('* {}\n'.format(msg))
    sys.exit(1)


def run_command(
        command, ignore_error=False, return_stdout=False, capture_stdout=True):
    if not isinstance(command, (list, tuple)):
        command = [command, ]
    command_str = ' '.join(command)
    log_info('Running command {}'.format(command_str))
    try:
        if capture_stdout:
            stdout = subprocess.check_output(command)
        else:
            subprocess.check_call(command)
            stdout = None
    except subprocess.CalledProcessError as err:
        if not ignore_error:
            handle_error('Command failed: {}'.format(err))
    else:
        return stdout.decode() if return_stdout else None

InformationsquelleAutor der Antwort aknuds1

Mithilfe von AWS cli habe ich versucht aws ecs-update-service wie oben vorgeschlagen. Nicht abholen neueste docker von ECR. Am Ende habe ich erneut meine Ansible playbook, erstellt das ECS-cluster. Die version des task-definition gestoßen, wenn ecs_taskdefinition läuft. Dann ist alles gut. Das neue Andockfenster Bild abgeholt wird.

Wahrheitsgemäß nicht sicher, ob der task version Kräfte ändern die erneut bereitstellen, oder, wenn das playbook mit dem ecs_service bewirkt, dass die Aufgabe neu zu laden.

Wenn jemand interessiert ist, werde ich die Erlaubnis bekommen, zu veröffentlichen eine bereinigte version von meinem playbook.

InformationsquelleAutor der Antwort mpechner