In diesem ersten Kapitel lernst du die Unterschiede zwischen Batch- und Stream-Verarbeitung kennen, erstellst deinen ersten Stream, verwaltest seine Berechtigungen, schreibst in ihn und liest aus ihm.

Was ist Streaming und warum ist es wichtig?

Optionen

Batch

Stream

Batch vs. Stream

Datenproduzenten

...Daten in den Firehose Stream stellen

...der es an das Ziel liefert

Erzeuger und Bestimmungsorte

Verwaltung von Firehose-Lieferströmen

Vorbereitung auf den ersten Stream

Rollen erstellen

IAM Benutzer

Rolle

Sowohl IAM Benutzer als auch Rollen

IAM Benutzer vs. Rollen

Berechtigungen nur für Benutzer

Berechtigungen für Benutzer und Rolle

Praxis der Erlaubniserteilung

S3 Bucket erstellen

Arbeiten mit dem Firehose Lieferstrom

# _setup.py: Create clients, load data, etc. No need to edit.

import boto3

# Create firehose client
firehose = boto3.client('firehose', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4573")

# Create s3 client
s3 = boto3.client('s3', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4572")

# Prep variables for export
ex_vars = [firehose, s3]


# create_firehose.py: Create firehose stream. No need to edit.
import _setup
firehose, s3 = _setup.ex_vars

# Create s3 bucket
s3.create_bucket(Bucket='sd-vehicle-data')

# Create Firehose delivery stream
res = firehose.____(
    DeliveryStreamName="gps-delivery-stream",
    DeliveryStreamType="DirectPut",
    # Specify configuration of the destination S3 bucket
    ____ = {
        "BucketARN": "arn:aws:s3:::sd-vehicle-data",
        "RoleARN": "arn:aws:iam::0000000:role/firehoseDeliveryRole"
    })
    
# Print the stream ARN
print("Created Firehose Stream ARN: {}".format(res['DeliveryStreamARN']))


# _setup.py: Create clients, load data, etc. No need to edit.
import boto3

# Create firehose client
firehose = boto3.client('firehose', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4573")

# Create s3 client
s3 = boto3.client('s3', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4572")

# Prep variables for export
ex_vars = [firehose, s3]


# create_firehose.py: Create firehose stream. No need to edit.
import _setup
firehose, s3 = _setup.ex_vars

# Create s3 bucket
s3.create_bucket(Bucket='sd-vehicle-data')

# Create Firehose delivery stream
res = firehose.create_delivery_stream(
    DeliveryStreamName =  "gps-delivery-stream",
    DeliveryStreamType = "DirectPut",
    
    # Specify configuration of the destination S3 bucket
    S3DestinationConfiguration = {
        "BucketARN": "arn:aws:s3:::sd-vehicle-data",
        "RoleARN": "arn:aws:iam::0000000:role/firehoseDeliveryRole"
    })
    
# Print the stream ARN
print("Created Firehose Stream ARN: {}".format(res['DeliveryStreamARN']))


Erstelle deinen ersten Firehose Stream

# _setup.py: Create clients, load data, etc. No need to edit.
import boto3, pandas as pd

# Load Data
data_url = "https://assets.datacamp.com/production/repositories/5668/datasets/6bba555e0e42ae31d1d634256679db718cfb8d76/vehicles.csv"
records = pd.read_csv(data_url).head(100)

# Create firehose client
firehose = boto3.client('firehose', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4573")

# Create s3 client
s3 = boto3.client('s3', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4572")
    
# Prep variables for export
ex_vars = [firehose, s3, records]
    


# create_firehose.py: Create firehose stream. No need to edit.
import _setup
firehose, s3, records = _setup.ex_vars

# Create s3 bucket
s3.create_bucket(Bucket='sd-vehicle-data')

# Create Firehose delivery stream
res = firehose.create_delivery_stream(
    DeliveryStreamName =  "gps-delivery-stream",
    DeliveryStreamType = "DirectPut",
    
    # Specify configuration of the destination S3 bucket
    S3DestinationConfiguration = {
        "BucketARN": "arn:aws:s3:::sd-vehicle-data",
        "RoleARN": "arn:aws:iam::0000000:role/firehoseDeliveryRole"
    })
    


# OBD2_sensors.py: Write to Firehose stream. EDIT HERE.
import _setup, create_firehose
firehose, s3, records = _setup.ex_vars
for idx, row in records.iterrows(): 

    # Create a payload string that ends with a newline
    payload = ' '.join(str(value) for value in row) 
    payload = payload + "\n"
    print("Sending payload: {}".format(payload))

    # Send the payload string to Firehose stream
    res = firehose.____(
        DeliveryStreamName = 'gps-delivery-stream',
        Record = {'____': payload})

    # Print the written RecordId
    print("Wrote to RecordId: {}".format(res['RecordId']))


# OBD2_sensors.py: Write to Firehose stream. EDIT HERE.
import _setup, create_firehose
firehose, s3, records = _setup.ex_vars
for idx, row in records.iterrows(): 

    # Create a payload string that ends with a newline
    payload = ' '.join(str(value) for value in row) 
    payload = payload + "\n"
    print("Sending payload: {}".format(payload))

    # Send the payload string to Firehose stream
    res = firehose.put_record(
        DeliveryStreamName = 'gps-delivery-stream',
        Record = {'Data': payload})

    # Print the written RecordId
    print("Wrote to RecordId: {}".format(res['RecordId']))


Schreiben in einen Firehose-Stream

# _setup.py: Create clients, load data, etc. No need to edit.
import boto3, pandas as pd

# Load Data
data_url = "https://assets.datacamp.com/production/repositories/5668/datasets/6bba555e0e42ae31d1d634256679db718cfb8d76/vehicles.csv"
records = pd.read_csv(data_url).sample(100)

# Create firehose client
firehose = boto3.client('firehose', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4573")

# Create s3 client
s3 = boto3.client('s3', 
    aws_access_key_id="None", 
    aws_secret_access_key="None", 
    region_name='us-east-1', 
    endpoint_url="http://localhost:4572")
    
# Prep variables for export
ex_vars = [firehose, s3, records]
    


# _run_deps.py: Execute dependencies. No need to edit.
import create_firehose
import OBD2_sensors


# create_firehose.py: Create firehose stream and s3 bucket. No need to edit.
import _setup
firehose, s3, records = _setup.ex_vars

# Create s3 bucket
s3.create_bucket(Bucket='sd-vehicle-data')

# Create Firehose delivery stream
res = firehose.create_delivery_stream(
    DeliveryStreamName =  "gps-delivery-stream",
    DeliveryStreamType = "DirectPut",
    
    # Specify configuration of the destination S3 bucket
    S3DestinationConfiguration = {
        "BucketARN": "arn:aws:s3:::sd-vehicle-data",
        "RoleARN": "arn:aws:iam::0000000:role/firehoseDeliveryRole"
    })
    


# OBD2_sensors.py: Write OBD2 sensor data. No need to edit.
import _setup
firehose, s3, records = _setup.ex_vars
for idx, row in records.iterrows(): 

    # Create a payload string that ends with a newline
    payload = ' '.join(str(value) for value in row) 
    payload = payload + "\n"

    # Send the payload string to Firehose stream
    res = firehose.put_record(
        DeliveryStreamName = 'gps-delivery-stream',
        Record = {'Data': payload})
    


# analyze_data.py: Analyze written sensor data. EDIT HERE.
import _setup, _run_deps, pandas as pd
firehose, s3, records = _setup.ex_vars

# List the objects that have been written to the S3 bucket
objects = s3.____(Bucket='sd-vehicle-data')['Contents']

# Create list for collecting dataframes from read files.
dfs = []

# For every object, load it from S3
for obj in objects:
    data_file = s3.____(Bucket='sd-vehicle-data', ____=obj['Key'])

    # Load it into a dataframe, specifying a delimiter and column names
    dfs.append(pd.read_csv(data_file['Body'], 
                           delimiter = " ", 
                           names=["record_id", "timestamp", "vin", "lon", "lat", "speed"]))

# Concatenate the resulting dataframes.
data = pd.concat(dfs)
print(data.groupby(['vin'])['speed'].max())

# OBD2_sensors.py: Analyze written sensor data. EDIT HERE.
import _setup, _run_deps, pandas as pd
firehose, s3, records = _setup.ex_vars

# List the objects that have been written to the S3 bucket
objects = s3.list_objects(Bucket='sd-vehicle-data')['Contents']

# Create list for collecting dataframes from read files.
dfs = []

# For every object, load it from S3
for obj in objects:
    data_file = s3.get_object(Bucket='sd-vehicle-data', Key=obj['Key'])

    # Load it into a dataframe, specifying a delimiter and column names
    dfs.append(pd.read_csv(data_file['Body'], 
                           delimiter = " ", 
                           names=["record_id", "timestamp", "vin", "lon", "lat", "speed"]))

# Concatenate the resulting dataframes.
data = pd.concat(dfs)
print(data.groupby(['vin'])['speed'].max())


Firehose-Daten lesen

Streaming in der Cloud

Der nächste Schritt auf deiner Streaming-Data-Reise ist zu lernen, wie du transformative Lambda-Funktionen nutzen kannst, um serverlos zu werden. In praktischen Übungen fügst du Lambda-Ebenen hinzu und löst Lambda-Funktionen bei bestimmten Bedingungen aus.

Serverlos werden

Lambda-Funktionen erstellen und ausführen

Serverlos vs. Server

Komponenten der Lambda-Funktion

Lesen von Daten aus S3 auf der Grundlage eines Ereignisses

Dein erstes Live-Lambda!

Hinzufügen einer Lambda-Ebene

Lambda flow

Umgebungsvariablen verwenden

Serverloser Daten-Workflow

Schnelle vs. langsame Lambdas

Ein zeitgesteuertes Lambda

Zeitgesteuerter Lambda-Code

Serverlose APIs

Ein API-Lambda erstellen

Eine serverlose API

Jetzt kannst du Streaming-Daten kodieren und dekodieren und die Daten direkt im Stream analysieren. Du wirst sogar mehrere Streams verwenden, um die täglichen Höchstgeschwindigkeiten der Fahrzeuge zu erhalten.

Ein transformatives Lambda

Daten innerhalb eines Streams umwandeln

Base64 kodieren und dekodieren

Erstellen eines Transformations-Lambdas

Ein einfaches Transformations-Lambda

Analysieren von Daten im Stream

Erstellen einer Kinesis-Datenanalyseanwendung

Kinesis Data Analytics vs. Transformational Lambda

Aufbau einer Kinesis-Datenanalyseanwendung

Kinesis data analytics SQL Komponenten

Mehrere Streams verwenden

Bereitstellung von Daten aus Kinesis Analytics

Erhalte die tägliche Höchstgeschwindigkeit

Verwendung von Kinesis-Datenanalysen für Warnungen

Analysieren von Streaming-Daten

In diesem letzten Kapitel erfährst du, wie du die Leistung deines Streams mithilfe von Protokollen, Metriken, Alarmen und Dashboards überwachen kannst. Du wirst Elasticsearch verwenden und dein eigenes Kibana-Dashboard erstellen.

Fallstudie zu Streaming-Daten

Erstellen eines Elasticsearch-Clusters

RedShift vs. Elasticsearch

Leistung überwachen

Cloudwatch dasbhoards und Alarme

Cloudwatch Komponenten

Cloudwatch Überwachungsablauf

Visualisierung von Streaming-Daten

Arbeiten mit ElasticSearch unter Verwendung von Kibana

Cloudwatch vs. Elasticsearch

Elasticsearch Visualisierungsablauf

Ein alternativer Ansatz

Ein anderer alternativer Ansatz

Überwachung und Visualisierung von Streaming-Daten

Was treibt die Systeme an, die wir jeden Tag benutzen, ohne es zu merken, wie z.B. die Betrugserkennung, die unsere Transaktionen sicher macht, oder die Verkehrssignale, die für einen reibungslosen Verkehrsfluss sorgen? Die Antwort sind Streaming-Daten (Daten, die kontinuierlich von verschiedenen Quellen erzeugt werden) und serverlose Technologien wie Amazon Kinesis und AWS Lambda.
<br /> <br />
In diesem Kurs lernst du, wie du diese leistungsstarken Technologien nutzen kannst, indem du einem fiktiven Dateningenieur namens Cody hilfst. Dein Ziel ist es, ihr dabei zu helfen, Echtzeit-Datenströme von stadteigenen Fahrzeugen zu sammeln, die Daten zu analysieren und relevante Warnungen wie Geschwindigkeitswarnungen an die Fahrer zu senden. Mit Amazon Kinesis und Firehose lernst du, wie du Daten aus Millionen von Quellen einlesen kannst, bevor du Kinesis Analytics nutzt, um die Daten zu analysieren, während sie sich durch den Stream bewegen. Du wirst auch serverlose Funktionen in AWS Lambda erstellen, die basierend auf den empfangenen Daten bedingte Aktionen auslösen. Am Ende dieser Schulung wirst du wissen, wie du mit AWS QuickSight und CloudWatch Live-Dashboards mit ElasticSearch erstellst - und hoffentlich Cody geholfen haben, ihr ehrgeiziges Projekt zu vollenden.


Introduction to AWS Boto in Python

Introduction to Shell

Streaming Concepts

Erfahren Sie, wie Sie mit serverlosen Technologien auf AWS Streaming-Daten verarbeiten.

Datenstreaming mit AWS Kinesis und Lambda

Erlerne den Umgang mit kontinuierlichen Datenströmen mithilfe von serverlosen Technologien basierend auf AWS.

Was ist Streaming und warum ist es wichtig?

Create Your Free Account