Zephyrnet-logo

Generativ dataintelligens

Store data

Kjør Kinesis Agent på Amazon ECS | Amazon Web Services

Publisert av Platon
Publisert av Platon

Dato:

Visninger: 89

Kinesis Agent er en frittstående Java-programvare som tilbyr en enkel måte å samle inn og sende data til Amazon Kinesis datastrømmer og Amazon Kinesis Data Firehose. Agenten overvåker kontinuerlig et sett med filer og sender nye data til ønsket destinasjon. Agenten håndterer filrotasjon, sjekkpunkter og prøver på nytt ved feil. Den leverer alle dataene dine på en pålitelig, rettidig og enkel måte. Det avgir også Amazon CloudWatch beregninger for å hjelpe deg bedre å overvåke og feilsøke strømmeprosessen.

Dette innlegget beskriver trinnene for å sende data fra en containerisert applikasjon til Kinesis Data Firehose ved hjelp av Kinesis Agent. Mer spesifikt viser vi hvordan du kjører Kinesis Agent som en sidevognsbeholder for en applikasjon som kjører inn Amazon Elastic Container Service (Amazon ECS). Etter at dataene er i Kinesis Data Firehose, kan de sendes til alle støttede destinasjonen, Eksempel Amazon enkel lagringstjeneste (Amazon S3).

For å presentere nøkkelpunktene som kreves for dette oppsettet, antar vi at du er kjent med Amazon ECS og arbeider med containere. Vi unngår også implementeringsdetaljene og pakkeprosessen til vår testdatagenereringsapplikasjon, referert til som produsenten.

Løsningsoversikt

Som vist i følgende figur, konfigurerer vi en Kinesis Agent-beholder som en sidevogn som kan lese filer opprettet av produsentbeholderen. I dette tilfellet deler produsenten og Kinesis Agent-beholdere data via en bindefeste i Amazon ECS.

Løsningsdesigndiagram

Forutsetninger

Du bør tilfredsstille følgende forutsetninger for vellykket gjennomføring av denne oppgaven:

Med disse forutsetningene på plass, kan du begynne neste trinn for å pakke en Kinesis Agent og ønsket agentkonfigurasjon som en beholder i din lokale utviklingsmaskin.

Opprett en Kinesis Agent-konfigurasjonsfil

Vi bruker Kinesis Agent konfigurasjonsfil for å konfigurere kilden og destinasjonen, blant andre dataoverføringsinnstillinger. Følgende kode bruker den minimale konfigurasjonen som kreves for å lese innholdet i filene som samsvarer /var/log/producer/*.log og publiser dem til en Kinesis Data Firehose-leveringsstrøm kalt kinesis-agent-demo:

{
    "firehose.endpoint": "firehose.ap-southeast-2.amazonaws.com",
    "flows": [
        {
            "deliveryStream": "kinesis-agent-demo",
            "filePattern": "/var/log/producer/*.log"
        }
    ]
}

Opprett et beholderbilde for Kinesis Agent

For å distribuere Kinesis Agent som en sidevogn i Amazon ECS, må du først pakke den som et containerbilde. Beholderen må ha Kinesis Agent, which og find binærfiler og Kinesis Agent-konfigurasjonsfilen som du forberedte tidligere. Inngangspunktet må konfigureres ved hjelp av start-aws-kinesis-agent manus. Denne kommandoen installeres når du kjører yum install aws-kinesis-agent steg. Den resulterende Dockerfilen skal se ut som følger:

FROM amazonlinux

RUN yum install -y aws-kinesis-agent which findutils
COPY agent.json /etc/aws-kinesis/agent.json

CMD ["start-aws-kinesis-agent"]

Kjør docker build kommando for å bygge denne beholderen:

docker build -t kinesis-agent .

Etter at bildet er bygget, bør det skyves til et beholderregister som Amazon ECR, slik at du kan referere til det i neste avsnitt.

Lag en ECS-oppgavedefinisjon med Kinesis Agent og applikasjonsbeholderen

Nå som du har Kinesis Agent pakket som et containerbilde, kan du bruke det i ECS-oppgavedefinisjonene for å kjøre som sidevogn. For å gjøre det oppretter du en ECS-oppgavedefinisjon med applikasjonsbeholderen din (kalt producer) og Kinesis Agent-beholder. Alle beholdere i en oppgavedefinisjon er planlagt på samme beholdervert og kan derfor dele ressurser som bindingsmonteringer.

I følgende eksempelbeholderdefinisjon bruker vi et bind-mount kalt logs_dir å dele en katalog mellom producer beholder og kinesis-agent container.

Du kan bruke følgende mal som utgangspunkt, men husk å endre taskRoleArn og executionRoleArn til gyldige IAM-roller i AWS-kontoen din. I dette tilfellet brukes IAM-rollen til taskRoleArn må ha skrivetillatelser til Kinesis Data Firehose som du spesifiserte tidligere i agent.json fil. I tillegg må du sørge for at ECR-bildebanene og awslogs-region endres i henhold til din AWS-konto.

{
    "family": "kinesis-agent-demo",
    "taskRoleArn": "arn:aws:iam::111111111:role/kinesis-agent-demo-task-role",
    "executionRoleArn": "arn:aws:iam::111111111:role/kinesis-agent-test",
    "networkMode": "awsvpc",
    "containerDefinitions": [
        {
            "name": "producer",
            "image": "111111111.dkr.ecr.ap-southeast-2.amazonaws.com/producer:latest",
            "cpu": 1024,
            "memory": 2048,
            "essential": true,
            "command": [
                "-output",
                "/var/log/producer/test.log"
            ],
            "mountPoints": [
                {
                    "sourceVolume": "logs_dir",
                    "containerPath": "/var/log/producer",
                    "readOnly": false
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "producer",
                    "awslogs-stream-prefix": "producer",
                    "awslogs-region": "ap-southeast-2"
                }
            }
        },
        {
            "name": "kinesis-agent",
            "image": "111111111.dkr.ecr.ap-southeast-2.amazonaws.com/kinesis-agent:latest",
            "cpu": 1024,
            "memory": 2048,
            "essential": true,
            "mountPoints": [
                {
                    "sourceVolume": "logs_dir",
                    "containerPath": "/var/log/producer",
                    "readOnly": true
                }
            ],
            "logConfiguration": {
                "logDriver": "awslogs",
                "options": {
                    "awslogs-create-group": "true",
                    "awslogs-group": "kinesis-agent",
                    "awslogs-stream-prefix": "kinesis-agent",
                    "awslogs-region": "ap-southeast-2"
                }
            }
        }
    ],
    "volumes": [
        {
            "name": "logs_dir"
        }
    ],
    "requiresCompatibilities": [
        "FARGATE"
    ],
    "cpu": "2048",
    "memory": "4096"
}

Registrer oppgavedefinisjonen med følgende kommando:

aws ecs register-task-definition --cli-input-json file://./task-definition.json

Kjør en ny ECS-oppgave

Til slutt kan du kjøre en ny ECS-oppgave ved å bruke oppgavedefinisjonen du nettopp opprettet ved hjelp av aws ecs run-task kommando. Når oppgaven er startet, skal du kunne se to beholdere som kjører under den oppgaven på Amazon ECS-konsollen.

Skjermbilde av Amazon ECS-konsoll

konklusjonen

Dette innlegget viste hvor enkelt det er å kjøre Kinesis Agent i et containerisert miljø. Selv om vi brukte Amazon ECS som vår container orkestreringstjeneste i dette innlegget, kan du bruke en Kinesis Agent container i andre miljøer som f.eks. Amazon Elastic Kubernetes-tjeneste (Amazon EKS).

For å lære mer om bruk av Kinesis Agent, se Skrive til Amazon Kinesis-datastrømmer ved å bruke Kinesis Agent. For mer informasjon om Amazon ECS, se Amazon ECS utviklerveiledning.

om forfatteren

Buddhike de Silva er Senior Specialist Solutions Architect hos Amazon Web Services. Buddhike hjelper kunder med å kjøre storskala strømmeanalysearbeidsmengder på AWS og få det beste ut av skyreisen deres.

spot_img

Siste etterretning

spot_img

Copyright @ 2024 Plato Technologies Inc.