AWS Mobile Hub – Entwicklerhandbuch - Entwicklerhandbuch · 2020. 7. 16. · AWS Mobile Hub – Entwicklerhandbuch Entwicklerhandbuch Entwicklung mobiler und Web-Apps Das Amplify

AWS Mobile Hub –Entwicklerhandbuch

Entwicklerhandbuch

AWS Mobile Hub – Entwicklerhandbuch: EntwicklerhandbuchCopyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

AWS Mobile Hub – Entwicklerhandbuch Entwicklerhandbuch

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,in any manner that is likely to cause confusion among customers, or in any manner that disparages or discreditsAmazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may notbe affiliated with, connected to, or sponsored by Amazon.


Table of ContentsEntwicklung mobiler und Web-Apps ....................................................................................................... 1Referenz ........................................................................................................................................... 2

SDK-API-Referenzen ................................................................................................................... 2AWS Mobile Hub-Referenz ......................................................................................................... 2

Android und iOS ................................................................................................................. 2Web ................................................................................................................................. 3React Native .................................................................................................................... 38Mobile Hub-Funktionen ...................................................................................................... 54Nutzung von IAM .............................................................................................................. 81Regionales Projektservicehosting ........................................................................................ 91Fehlersuche in Projekten .................................................................................................... 97Exportieren und Importieren von Projekten .......................................................................... 101Amazon CloudFront – Sicherheit ....................................................................................... 113Amazon S3-Sicherheit ...................................................................................................... 115

iii


Entwicklung mobiler und Web-AppsDas Amplify Framework ermöglicht Entwicklern das Erstellen von Cloud-basierten mobilen und Web-Apps.Es enthält eine umfassende Palette von SDKs, Bibliotheken, Tools und Dokumentationen für die Client-App-Entwicklung. Erfahren Sie jetzt weitere Informationen oder Unternehmen Sie erste Schritte mit demAmplify Framework.

1

https://aws-amplify.github.io/

https://aws-amplify.github.io/docs

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchSDK-API-Referenzen

AWS Mobile-ReferenzThemen

• Android- und iOS-API-Referenzen (p. 2)• AWS Mobile Hub-Referenz (p. 2)

Android- und iOS-API-ReferenzenAndroid

• AWS Mobile SDK für Android – API-Referenz• AWS SDK für Mobilgeräte auf GitHub• AWS SDK für Mobilgeräte für Android Beispiele

iOS

• AWS Mobile SDK für iOS – API-Referenz• AWS Mobile SDK für iOS auf GitHub• AWS Mobile SDK für iOS – Beispiele

AWS Mobile Hub-ReferenzThemen

• AWS Mobile für Android und iOS (p. 2)• AWS Amplify-Bibliothek für Web (p. 3)• AWS Amplify-Bibliothek für React Native (p. 38)• AWS Mobile Hub-Funktionen (p. 54)• Nutzung von AWS Identity and Access Management in AWS Mobile Hub (p. 81)• Hosting in bestimmten Regionen für Mobile Hub-Projekte (p. 91)• Fehlersuche im Mobile Hub-Projekt (p. 97)• Importieren und Exportieren von AWS Mobile Hub-Projekten (p. 101)• Amazon CloudFront-Sicherheitsüberlegungen für Mobile Hub-Benutzer (p. 113)• Amazon S3-Sicherheitsüberlegungen für Mobile Hub-Benutzer (p. 115)

AWS Mobile für Android und iOSDie AWS Mobile SDKs für Android und iOS sind jetzt Teil der Amplify Framework-Dokumentation. WeitereInformationen finden Sie unter den folgenden Links:

• Amplify Android – Empfohlen für die Entwicklung neuer mit der Cloud verbundener Android-Apps.

2

https://docs.aws.amazon.com/AWSAndroidSDK/latest/javadoc/

https://github.com/aws/aws-sdk-android

https://github.com/awslabs/aws-sdk-android-samples

https://docs.aws.amazon.com/AWSiOSSDK/latest/

https://github.com/aws/aws-sdk-ios

https://github.com/awslabs/aws-sdk-ios-samples

https://docs.amplify.aws/lib/q/platform/android

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchWeb

• Amplify iOS – Empfohlen für die Entwicklung neuer mit der Cloud verbundener iOS-Apps.• AWS Mobile SDK für Android — AWS-Service-spezifische Low-Level-APIs für mit der Cloud verbundene

Android-Apps.• AWS Mobile SDK für iOS — AWS-Service-spezifische Low-Level-APIs für mit der Cloud verbundene

iOS-Apps.

AWS Amplify-Bibliothek für WebImportant

Der folgende Inhalt trifft zu, wenn Sie bereits die AWS Mobile-CLI zum Konfigurieren IhresBackends verwenden. Wenn Sie eine neue mobile oder Web-App erstellen oder Cloud-Funktionenzu einer vorhandenen App hinzufügen, verwenden Sie stattdessen die neue AWS Amplify-CLI.Mit der neuen Amplify-CLI können Sie alle unter Ankündigung der AWS Amplify-CLI-Toolchainbeschriebenen Funktionen nutzen, einschließlich AWS CloudFormation-Funktionalität, diezusätzliche Workflows bereitstellt.

AWS Amplify ist eine Open-Source-JavaScript-Bibliothek für Frontend-Entwickler und Entwickler mobilerApps, die Cloud-fähige Anwendungen erstellen. Die Bibliothek ist eine deklarative Schnittstelle vielerunterschiedlicher Kategorien von Vorgängen, um das Hinzufügen häufiger Aufgaben zu Ihrer Anwendungzu vereinfachen. Die Standardimplementierung funktioniert mit Amazon Web Services (AWS)-Ressourcen,wurde jedoch offen und Plug-in-fähig konzipiert, für die Verwendung mit anderen Cloud-Services, die eineImplementierung oder benutzerdefinierte Backends bereitstellen möchten.

Die AWS Mobile CLI, die auf AWS Mobile Hub basiert, bietet eine Befehlszeilenschnittstelle für Frontend-JavaScript-Entwickler, um AWS-Services nahtlos zu aktivieren und in ihre Apps zu konfigurieren. Mit nurminimalem Konfigurationsaufwand können Sie die gesamte Funktionalität nutzen, die von AWS Mobile Hubaus der von Ihnen bevorzugten Terminal-Anwendung bereitgestellt wird.

Themen• Loslegen (p. 3)• AWS Mobile Hub-Funktionen (p. 24)

LoslegenImportant


Übersicht

Die AWS Mobile CLI bietet eine Befehlszeilenschnittstelle für Frontend-JavaScript-Entwickler, um schnellAWS-Backend-Ressourcen zu erstellen und in ihre mobilen Apps zu integrieren.

Voraussetzungen

1. Registrieren Sie sich für das kostenlose Kontingent für AWS.2. Installieren Sie Node.js mit NPM.

3

https://docs.amplify.aws/lib/q/platform/ios

https://docs.amplify.aws/sdk/q/platform/android

https://docs.amplify.aws/sdk/q/platform/ios

http://aws-amplify.github.io/

http://aws.amazon.com/blogs/mobile/announcing-the-aws-amplify-cli-toolchain/

https://aws.github.io/aws-amplify/



https://aws.amazon.com/free/

https://nodejs.org/en/download/


3. Installieren Sie die AWS Mobile CLI.

npm install -g awsmobile-cli

4. Konfigurieren Sie die CLI mit Ihren AWS-Anmeldeinformationen.

Führen Sie zum Einrichten der Berechtigungen für die von der CLI verwendete Tool-Chain denfolgenden Befehl aus:

awsmobile configure

Wenn Sie aufgefordert werden, Anmeldeinformationen einzugeben, befolgen Sie die Anleitung in derCLI. Weitere Informationen finden Sie im Thema zum Bereitstellen von IAM-Anmeldeinformationen fürdie AWS Mobile CLI (p. 35).

Einrichten Ihres Backends

Sie müssen schnell eine Beispiel-React-App erstellen? Weitere Informationen finden Sie unter Erstelleneiner React Native-App.

So konfigurieren Sie Backend-Funktionen für Ihre App

1. Führen Sie im Stammverzeichnis Ihrer App Folgendes aus:

awsmobile init

Mit dem Befehl init erstellen Sie ein Backend-Projekt für Ihre App. Standardmäßig sind Analysenund Web-Hosting in Ihrem Backend aktiviert und die Konfiguration wird in der App beim Initialisierenautomatisch geöffnet.

2. Wenn Sie dazu aufgefordert werden, geben Sie das Quellverzeichnis für Ihr Projekt an. Die CLI erzeugtan diesem Speicherort die Datei aws-exports.js. Sie enthält die Konfiguration und Endpunkt-Metadaten, die zum Verknüpfen Ihrer Frontend- mit Ihren Backend-Services verwendet werden.

? Where is your project's source directory: src

3. Geben Sie auf Aufforderung folgende Werte ein:

? Where is your project's distribution directory to store build artifacts: build? What is your project's build command: npm run-script build? What is your project's start command for local test run: npm run-script start? What awsmobile project name would you like to use: YOUR-APP-NAME-2017-11-10-15-17-48

Nachdem das Projekt erstellt wurde erhalten Sie eine Erfolgsmeldung, die auch Details zum Pfad enthält, inden die Datei "aws-exports.js" kopiert wurde.

awsmobile project's details logged at: awsmobilejs/#current-backend-info/backend-details.jsonawsmobile project's access information logged at: awsmobilejs/#current-backend-info/aws-exports.jsawsmobile project's access information copied to: src/aws-exports.jsawsmobile project's specifications logged at: awsmobilejs/#current-backend-info/mobile-hub-project.yml

4

https://reactjs.org/blog/2016/07/22/create-apps-with-no-configuration.html

https://reactjs.org/blog/2016/07/22/create-apps-with-no-configuration.html


contents in #current-backend-info/ is synchronized with the latest information in the aws cloud

Das Projekt ist nun initialisiert.

Note

Sie können die AWS-Backend-Ressourcen, die Sie für dieses Projekt erstellen, mit awsmobileinit YOUR_MOBILE_HUB_PROJECT_ID einer anderen vorhandenen App hinzufügen. Um dieProjekt-ID abzurufen, öffnen Sie das Mobile Hub-Projekt in der Mobile Hub-Konsole, indem Sieawsmobile console ausführen. Die Projekt-ID ist der GUID-Bestandteil der Konsolenadresseim Format XXXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX.

Herstellen einer Verbindung mit Ihrem Backend

AWS Mobile verwendet die Open Source-Bibliothek AWS Amplify, um Ihren Code mit den für Ihre Appkonfigurierten AWS-Funktionen zu verknüpfen.

In diesem Abschnitt des Handbuchs werden Beispiele gezeigt, die eine React-Anwendung verwenden undCode von create-react-app oder einem ähnlichen Tool ausgeben.

So verbinden Sie die App mit Ihren konfigurierten AWS-Funktionen

Fügen Sie in index.js (oder anderem Code, der zur Startzeit ausgeführt wird), die folgenden Importehinzu.

import Amplify from 'aws-amplify';import awsmobile from './YOUR-PATH-TO/aws-exports';

Fügen Sie dann den folgenden Code hinzu.

Amplify.configure(awsmobile);

Lokales Ausführen der App

Sie können Ihre App nun starten und die von AWS Mobile konfigurierten Standard-Funktionen verwenden.

So starten Sie die App lokal in einem Browser

Führen Sie im Stammverzeichnis Ihrer App Folgendes aus:

awsmobile run

Im Hintergrund führt dieser Befehl npm install aus, um die Amplify-Bibliothek zu installieren sowieÄnderungen an der Backend-Konfiguration an AWS Mobile zu senden. Um die App lokal auszuführen,ohne Backend-Änderungen zu senden, könne Sie npm install und dann npm start ausführen.

Bei jedem Start der App werden App-Analysen erfasst und können in der AWS-Konsole angezeigtwerden (p. 8).

Kostenloses Kontingent für AWS Wenn Sie die App über die CLI initialisieren oderüber die CLI Funktionen hinzufügen, werdenAWS-Services in Ihrem Namen konfiguriert.

5

https://aws.github.io/aws-amplify


Die Preise für AWS Mobile-Services sind sokonzeptioniert, dass Sie mit dem kostenlosenAWS-Nutzungskontingent zu geringen Kosten oderkostenlos lernen und ausprobieren können.

Nächste Schritte

Themen• Bereitstellen der App in der Cloud (p. 6)• Testen der App auf unseren Mobilgeräten (p. 6)• Hinzufügen von Funktionen (p. 7)• Weitere Informationen (p. 8)

Bereitstellen der App in der Cloud

Mit einem einfachen Befehl können Sie das Frontend der App zum Hosten auf einem Netzwerk zurVerteilung von Inhalten (Content Distribution Network, CDN) sowie zur Anzeige in einem Browserveröffentlichen.

So stellen Sie die App in der Cloud bereit und starten diese in einem Browser


awsmobile publish

Um Änderungen an der Backend-Konfiguration an AWS zu senden und Inhalte lokal anzuzeigen,führen Sie awsmobile run aus. In beiden Fällen werden ausstehende Änderungen an der Backend-Konfiguration an den Backend-Ressourcen vorgenommen.

Standardmäßig konfiguriert die CLI die AWS Mobile-Funktion Hosting und Streaming (p. 65), die dieApp auf Amazon CloudFront CDN-Endpunkten hostet. An diesen Speicherorten erzielt die App eine hoheöffentliche Verfügbarkeit im Internet und unterstützt ein Streaming von Mediendateien.

Sie können als Host-Speicherort auch eine benutzerdefinierte Domäne verwenden (p. 22).

Testen der App auf unseren Mobilgeräten

Stoßen Sie einen kostenlosen Remote-Test der App auf den verschiedensten echten Geräten an undzeigen Sie die Ergebnisse an, einschließlich Screenshots.

So rufen Sie einen Remote-Test der App auf


awsmobile publish --test

Die CLI öffnet die Berichtsseite für die App in der Mobile Hub-Konsole und zeigt die von den Testgerätengesammelten Metriken an. Das Gerät, auf dem der Remote-Test von Ihnen aufgerufen wird, befindet sich inder AWS Device Farm, wo Sie Tests und Berichte flexibel konfigurieren können.

6

https://aws.amazon.com/mobile/pricing

https://aws.amazon.com/free


https://aws.amazon.com/cloudfront/

https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/on-demand-streaming-video.html

https://aws.amazon.com/device-farm/


Hinzufügen von Funktionen

Fügen Sie mithilfe der CLI Ihrer mobilen App die folgenden AWS Mobile-Funktionen hinzu.

• Analysen (p. 8)• Benutzeranmeldung (p. 9)• NoSQL-Datenbank (p. 10)• User File Storage (p. 15)• Cloud Logic (p. 18)

7


Weitere Informationen

Weitere Informationen zu den Befehlen und der Nutzung der AWS Mobile CLI finden Sie in der AWS MobileCLI-Referenz (p. 25).

Weitere Informationen zu AWS Mobile Amplify

Hinzufügen von AnalysenImportant


Aktivierung des Backend für einfache Analysen in der App

BEVOR SIE BEGINNEN Bei den Schritten auf dieser Seite gehen wir davonaus, dass Sie bereits die Schritte unter ErsteSchritte (p. 3) durchgearbeitet haben.

Nach Abschluss der Einrichtung von AWS Mobile CLI und dem Starten der App fließen anonymisiertedemografische Sitzungs- und Gerätedaten zum AWS-Analyse-Backend.

So senden Sie einfache Analysen der App-Nutzung an AWS

Starten Sie die App lokal, indem Sie Folgendes ausführen:

npm start

Wenn Sie die App verwenden, erfasst und visualisiert der Amazon Pinpoint-Service Analysedaten.

So zeigen Sie die Analysen mit der Amazon Pinpoint-Konsole an

1. Führen Sie npm start, awsmobile run oder awsmobile publish --test mindestens einmalaus.

2. Öffnen Sie das Projekt in der AWS Mobile Hub-Konsole.

awsmobile console

3. Wählen Sie auf der linken Seite das Symbol Analytics (Analysen) aus, um in der Amazon Pinpoint-Konsole zu Ihrem Projekt zu navigieren.

4. Wählen Sie auf der linken Seite Analytics (Analysen) aus.

Sie sollten eine steigende Tendenz in mehreren Diagrammen sehen.

Hinzufügen von benutzerdefinierten Analysen zur App

Sie können die App so konfigurieren, dass Amazon Pinpoint Daten für benutzerdefinierte Ereignissesammelt, die im Codefluss registriert sind.

So nutzen Sie benutzerdefinierte Analysen in der App

Fügen Sie der Datei, die das zu verfolgende Ereignis enthält, folgenden Import hinzu:

8




https://docs.aws.amazon.com/pinpoint/latest/developerguide/

https://console.aws.amazon.com/mobilehub/

https://console.aws.amazon.com/pinpoint/




import { Analytics } from 'aws-amplify';

Fügen Sie an der Stelle im JavaScript, an der das verfolgte Ereignis ausgelöst werden soll, einen Aufruf wieden folgenden ein:

componentDidMount() { Analytics.record('FIRST-EVENT-NAME');}

Oder auf relevante Seitenelemente:

handleClick = () => { Analytics.record('SECOND-EVENT-NAME');}

<button onClick={this.handleClick}>Call request</button>

So können Sie dies testen:

1. Speichern Sie zum Testen die Änderungen und führen Sie npm start, awsmobile run oderawsmobile publish --test aus, um die App zu starten. Verwenden Sie die App, sodass verfolgteEreignisse ausgelöst werden.

2. Wählen Sie in der Amazon Pinpoint-Konsole oben die Option Events (Ereignisse) aus.3. Wählen Sie links im Dropdown-Menü Event (Ereignis) ein Ereignis aus.

Benutzerdefinierte Ereignisdaten werden nach wenigen Minuten in der Konsole angezeigt.

Nächste Schritte

Erfahren Sie mehr zu den Analysen in AWS Mobile, die Teil der Funktion für Messaging undAnalysen (p. 63) sind. Diese Funktion verwendet Amazon Pinpoint.

Weitere Informationen zur AWS Mobile CLI (p. 25)


Hinzufügen einer Authentifizierungs-/BenutzeranmeldungImportant




Die AWS Mobile CLI-Komponenten für Benutzerauthentifizierung umfassen eine umfangreiche,konfigurierbare Benutzeroberfläche für die Registrierung und Anmeldung.

So aktivieren Sie die Authentifizierungsfunktionen

9


https://docs.aws.amazon.com/pinpoint/latest/developerguide/welcome.html






awsmobile user-signin enable

awsmobile push


Die AWS Mobile CLI ermöglicht Ihnen das Integrieren einer fertigen Registrierungs-/Anmelde-/Abmeldebenutzeroberfläche mithilfe der Befehlszeile.

So fügen Sie eine Benutzerauthentifizierungsbenutzeroberfläche zu Ihrer App hinzu

1. Installieren Sie AWS Amplify für die React-Bibliothek.

npm install --save aws-amplify-react

2. Fügen Sie App.js (oder einer anderen Datei, die beim Start der App aufgerufen wird) den folgendenImport hinzu:

import { withAuthenticator } from 'aws-amplify-react';

3. Ändern Sie dann export default App; wie folgt.

export default withAuthenticator(App);

Führen Sie zum Testen npm start, awsmobile run oder awsmobile publish --test aus.

Nächste Schritte

Erfahren Sie mehr über die Funktion für die Benutzeranmeldung (p. 72) von AWS Mobile, die AmazonCognito verwendet.



Zugriff auf Ihre DatenbankImportant



Die AWS Mobile CLI und die Amplify-Bibliothek vereinfachen CRUD-Aktionen (erstellen, lesen,aktualisieren und löschen) für in der Cloud gespeicherte Daten durch einfache API-Aufrufe in IhrerJavaScript-App.


10

https://docs.aws.amazon.com/cognito/latest/developerguide/welcome.html






So erstellen Sie eine Datenbank

1. Aktivieren Sie die NoSQL Database-Funktion und konfigurieren Sie Ihre Tabelle.


awsmobile database enable --prompt

2. Wählen Sie Open aus, um die Daten in dieser Tabelle für alle Benutzer der Anwendung sichtbar zumachen.

? Should the data of this table be open or restricted by user?# Open Restricted

3. Geben Sie für dieses Beispiel todos als Table name ein.

? Table name: todos

Hinzufügen von Spalten und Abfragen

Sie erstellen eine Tabelle in einer NoSQL-Datenbank und fügen erste Spalten mit einem Namen undDatentyp hinzu. Mit NoSQL können Sie jedes Mal, wenn Sie Daten speichern, die eine neue Spalteenthalten, eine Spalte hinzufügen. In NoSQL-Tabellen muss eine Spalte als primärer Schlüssel definiertsein, der als eindeutige Kennung für jede Zeile dient.

1. Befolgen Sie in diesem Beispiel die Aufforderungen, um drei Spalten hinzuzufügen: team(Zeichenfolge), todoId (Zahl) und text (Zeichenfolge).

? What would you like to name this column: team? Choose the data type: string

2. Geben Sie bei der Aufforderung ? Add another column Y ein und drücken Sie die Eingabetaste.Wiederholen Sie diese Schritte, um die Spalten todoId und text zu erstellen.

3. Wählen Sie als primären Schlüssel team aus.

? Select primary key# team todoId text

4. Wählen Sie als Sortierschlüssel (todoId) und dann für das Hinzufügen weiterer Indexe no aus, umdas Beispiel einfach zu halten.

Sortierschlüssel und Indexe Zur Leistungsoptimierung können Sie eine Spalteals Sortierschlüssel auswählen. Wählen Sieeine Spalte als Sortierschlüssel aus, die häufigzusammen mit dem primären Schlüssel fürTabellenabfragen verwendet wird. Sie könnenauch sekundäre Indexe erstellen, um zusätzlicheSpalten als Sortierschlüssel zu definieren.

? Select sort key# todoId

11

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SQLtoNoSQL.html


text (No Sort Key)

? Add index (Y/n): nTable todos saved.

Die todos-Tabelle wird nun erstellt.

Verwenden einer Cloud-API für CRUD-Operationen

Für den Zugriff auf Ihre NoSQL-Datenbank erstellen Sie eine API, die Sie in der App aufrufen können, umCRUD-Operationen auszuführen.

Warum eine API? Durch die Verwendung einer API für den Zugriffauf Ihre Datenbank wird eine einfache Code-Schnittstelle im Frontend und robuste Flexibilitätim Backend bereitgestellt. Im Hintergrund wirdein Aufruf an einen Amazon API Gateway-API-Endpunkt in der Cloud von einer serverlosenLambda-Funktion verarbeitet.

So erstellen Sie eine CRUD-API

1. Aktivieren und Konfigurieren der Cloud Logic-Funktion**

awsmobile cloud-api enable --prompt

2. Wählen Sie für eine bereits vorhandene Amazon DynamoDB-Tabelle Create CRUD API for anexisting Amazon DynamoDB table aus und drücken Sie die Eingabetaste.

? Select from one of the choices below. (Use arrow keys) Create a new API# Create CRUD API for an existing Amazon DynamoDB table

3. Wählen Sie die in den vorherigen Schritten erstellte todos-Tabelle aus und drücken Sie dieEingabetaste.

? Select Amazon DynamoDB table to connect to a CRUD API# todos

4. Verschieben Sie die Konfiguration in die Cloud. Ohne diesen Schritt ist die Konfiguration für IhreDatenbank und API nur lokal verfügbar.

awsmobile push

Die erforderlichen DynamoDB-Tabellen, API Gateway-Endpunkte und Lambda-Funktionen werden jetzterstellt.

Erstellen Ihres ersten Todos

Mit der AWS Mobile CLI können Sie Ihre API über die Befehlszeile testen.

Führen Sie den folgenden Befehl aus, um Ihr erstes Todo zu erstellen.

12

https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html

https://docs.aws.amazon.com/lambda/latest/dg/welcome.html


awsmobile cloud-api invoke todosCRUD POST /todos '{"body": {"team": "React", "todoId": 1, "text": "Learn more Amplify"}}'


Die Beispiele in diesem Abschnitt zeigen, wie Sie AWS Amplify-Bibliotheksaufrufe mithilfe von Reactintegrieren können (in der AWS Amplify-Dokumentation finden Sie Informationen zur Verwendung andererVarianten von JavaScript).

Die folgende Komponente ist eine einfache Todo-Liste, die Sie einem create-react-app-Projekthinzufügen können. Die Todo-Komponente kann derzeit todos zu einem Speicher-Array hinzufügen unddaraus anzeigen.

// To Do app example

import React from 'react';

class Todos extends React.Component { state = { team: "React", todos: [] };

render() { let todoItems = this.state.todos.map(({todoId, text}) => { return <li key={todoId}>{text}</li>; });

return ( <div style={styles}> <h1>{this.state.team} Todos</h1> <ul> {todoItems} </ul>

<form> <input ref="newTodo" type="text" placeholder="What do you want to do?" /> <input type="submit" value="Save" /> </form> </div> ); }}

let styles = { margin: "0 auto", width: "25%"};

export default Todos;

Anzeigen von Todos aus der Cloud

Mit dem API-Modul aus AWS Amplify können Sie eine Verbindung zu DynamoDB über API Gateway-Endpunkte herstellen.

So können Sie Elemente in einer Datenbank abrufen und anzeigen

1. Importieren Sie das API-Modul aus aws-amplify oben in der Todos-Komponentendatei.

import { API } from 'aws-amplify';

13



2. Fügen Sie das folgende componentDidMount zur Todos-Komponente hinzu, um alle todosabzurufen.

async componentDidMount() { let todos = await API.get('todosCRUD', `/todos/${this.state.team}`); this.setState({ todos });}

Wenn die Todos-Komponente gestartet wird, ruft sie alle in der Datenbank gespeicherten todos ab undzeigt sie an.

Speichern von Todos in der Cloud

Im folgenden Fragment wird die saveTodo-Funktion für die Todo-App gezeigt.

async saveTodo(event) { event.preventDefault();

const { team, todos } = this.state; const todoId = todos.length + 1; const text = this.refs.newTodo.value;

const newTodo = {team, todoId, text}; await API.post('todosCRUD', '/todos', { body: newTodo }); todos.push(newTodo); this.refs.newTodo.value = ''; this.setState({ todos, team });}

Aktualisieren Sie das form-Element in der Render-Funktion der Komponente, um die saveTodo-Funktionbeim Senden des Formulars aufzurufen.

<form onSubmit={this.saveTodo.bind(this)}>

Die gesamte Komponente sollte folgendermaßen aussehen:

// To Do app example

import React from 'react';import { API } from 'aws-amplify';

class Todos extends React.Component { state = { team: "React", todos: [] };

async componentDidMount() { const todos = await API.get('todosCRUD', `/todos/${this.state.team}`) this.setState({ todos }); }

async saveTodo(event) { event.preventDefault();

const { team, todos } = this.state; const todoId = todos.length + 1; const text = this.refs.newTodo.value;

const newTodo = {team, todoId, text}; await API.post('todosCRUD', '/todos', { body: newTodo });

14


todos.push(newTodo); this.refs.newTodo.value = ''; this.setState({ todos, team }); }

render() { let todoItems = this.state.todos.map(({todoId, text}) => { return <li key={todoId}>{text}</li>; });

return ( <div style={styles}> <h1>{this.state.team} Todos</h1> <ul> {todoItems} </ul>

<form onSubmit={this.saveTodo.bind(this)}> <input ref="newTodo" type="text" placeholder="What do you want to do?" /> <input type="submit" value="Save" /> </form> </div> ); }}

let styles = { margin: "0 auto", width: "25%"}

export default Todos;

Nächste Schritte

• Erfahren Sie, wie Sie mit dem API-Modul in AWS Amplify spezielle Elemente abrufen können und vielesmehr.

• Erfahren Sie, wie Sie mit der AWS Mobile CLI mehr Funktionen für Ihre App aktivieren können.

Hinzufügen von SpeicherImportant


Einrichten des Backends

Die AWS Mobile CLI und die AWS Amplify-Bibliothek vereinfachen das Speichern und Verwalten vonDateien in der Cloud aus Ihrer JavaScript-App.


15

https://aws.github.io/aws-amplify/media/developer_guide.html





Aktivieren Sie die Funktion User File Storage, indem Sie im Stammverzeichnis der App die folgendenBefehle ausführen.

awsmobile user-files enable

awsmobile push

Verbinden mit dem Backend


Die folgende einfache Komponente kann zu einem create-react-app-Projekt hinzugefügt werden, umeine Schnittstelle zum Hoch- und Herunterladen zum Anzeigen von Abbildungen darzustellen.

// Image upload and download for display example component// src/ImageViewer.js

import React, { Component } from 'react';

class ImageViewer extends Component { render() { return ( <div> <p>Pick a file</p> <input type="file" /> </div> ); }}

export default ImageViewer;

Hochladen einer Datei

Im Storage-Modus können Sie Dateien in die Cloud hochladen. Alle hochgeladenen Dateien sindstandardmäßig öffentlich sichtbar.

Importieren Sie das Storage-Modul in Ihre Komponentendatei.

// ./src/ImageViewer.js

import { Storage } from 'aws-amplify';

Fügen Sie die folgende Funktion hinzu, um die put-Funktion für das Storage-Modul zum Hochladen vonDateien in die Cloud zu verwenden und setzen Sie den Komponentenstatus auf den Namen der Datei.

uploadFile(event) { const file = event.target.files[0]; const name = file.name;

Storage.put(key, file).then(() => { this.setState({ file: name }); });}

16



Rufen Sie die uploadFile-Funktion im input-Element der Render-Funktion der Komponente auf, umden Upload zu starten, wenn ein Benutzer eine Datei auswählt.

render() { return ( <div> <p>Pick a file</p> <input type="file" onChange={this.uploadFile.bind(this)} /> </div> );}

Anzeigen einer Abbildung

In diesem Beispiel wird gezeigt, wie Sie zum Anzeigen einer Abbildung die S3Image-Komponente vonAWS Amplify für die React-Bibliothek verwenden.

1. Führen Sie in einem Terminal den folgenden Befehl im Stammverzeichnis Ihrer App aus.

npm install --save aws-amplify-react

2. Importieren Sie das S3Image-Modul in Ihre Komponente.

import { S3Image } from 'aws-amplify-react';

Verwenden Sie die S3Image-Komponente in der Render-Funktion. Aktualisieren Sie die Render-Funktionwie folgt:

render() { return ( <div> <p>Pick a file</p> <input type="file" onChange={this.handleUpload.bind(this)} /> { this.state && <S3Image path={this.state.path} /> } </div> );}

Zusammengenommen sieht die gesamte Komponente wie folgt aus:

// Image upload and download for display example component

import React, { Component } from 'react';import { Storage } from 'aws-amplify';import { S3Image } from 'aws-amplify-react';

class ImageViewer extends Component {

handleUpload(event) { const file = event.target.files[0]; const path = file.name; Storage.put(path, file).then(() => this.setState({ path }) ); }

render() { return ( <div> <p>Pick a file</p>

17


<input type="file" onChange={this.handleUpload.bind(this)} /> { this.state && <S3Image path={this.state.path} /> } </div> ); }}

export default ImageViewer;

Nächste Schritte

• Erfahren Sie, wie Sie mit dem Speichermodul in AWS Amplify private Dateispeicherung durchführen.• Erfahren Sie, wie Sie mit der AWS Mobile CLI mehr Funktionen für Ihre App aktivieren können.• Erfahren Sie, wie Sie mit der AWS Amplify-Bibliothek diese Funktionen in Ihrer App verwenden können.• Weitere Informationen zur Analyse für die Funktion zur Benutzerdateienspeicherung• Weitere Informationen zur Speicherung Ihrer Dateien im Amazon Simple Storage Service

Zugriff auf Ihre APIsImportant



Die AWS Mobile CLI und die Amplify-Bibliothek vereinfachen das Erstellen und Aufrufen von Cloud-APIsund deren Handler-Logik aus dem JavaScript.


Erstellen der API

In den folgenden Beispielen erstellen Sie eine API, die Teil einer Cloud-fähigen App für das Erraten vonZahlen ist. Die CLI erstellt hinter den Kulissen einen serverlosen Handler für die API.

So aktivieren und konfigurieren Sie eine API



2. Geben Sie, wenn Sie aufgefordert werden, der API den Namen Guesses.

? API name: Guesses

3. Benennen Sie einen HTTP-Pfad /number. Dies entspricht einem Methodenaufruf im API-Handler.

18




https://alpha-docs-aws.amazon.com/pinpoint/latest/developerguide/welcome.html

https://aws.amazon.com/documentation/s3/




? HTTP path name (/items): /number

4. Benennen Sie Ihre Lambda-API-Handler-Funktion guesses.

? Lambda function name (This will be created if it does not already exists): guesses

5. Wenn Sie dazu aufgefordert werden, einen weiteren HTTP-Pfad hinzuzufügen, geben Sie N ein.

? Add another HTTP path (y/N): N

6. Die Konfiguration für die "Guesses"-API wird nun lokal gespeichert. Verschieben Sie die Konfiguration indie Cloud.

awsmobile push

So testen Sie API und Handler

Führen Sie an der Befehlszeile Folgendes aus:

awsmobile cloud-api invoke Guesses GET /number

Der Cloud Logic API-Endpunkt für die Guesses-API ist nun erstellt.

Anpassen der API-Handler-Logik

Die AWS Mobile CLI hat eine Lambda-Funktion für die Verarbeitung von Aufrufen der Guesses-APIgeneriert. Sie wird lokal unter YOUR-APP-ROOT-FOLDER/awsmobilejs/backend/cloud-api/guesses gespeichert. Die Datei app.js in diesem Verzeichnis enthält die Definitionen und denfunktionalen Code für alle Pfade, die für die API verarbeitet werden.

So passen Sie den API-Handler an

1. Sie finden den Handler für POST-Anforderungen im /number-Pfad. Diese Zeile beginnt mitapp.post('number',. Ersetzen Sie den Text der Callback-Funktion durch Folgendes:

# awsmobilejs/backend/cloud-api/guesses/app.jsapp.post('/number', function(req, res) { const correct = 12; let guess = req.body.guess let result = ""

if (guess === correct) { result = "correct"; } else if (guess > correct) { result = "high"; } else if (guess < correct) { result = "low"; }

res.json({ result })});

2. Verschieben Sie die Änderungen in die Cloud.

awsmobile push

19


Die Guesses-API-Handler-Logik, die die neue Zahlenratefunktionalität implementiert, wird nun in der Cloudbereitgestellt.



Die folgende einfache Komponente könnte einem create-react-app-Projekt hinzugefügt werden, umdas Zahlenratespiel darzustellen.

// Number guessing game app example

# src/GuessNumber.js

class GuessNumber extends React.Component { state = { answer: null };

render() { let prompt = "" const answer = this.state.answer

switch (answer) { case "lower": prompt = "Incorrect. Guess a lower number." case "higher": prompt = "Incorrect. Guess a higher number." case "correct": prompt = `Correct! The number is ${this.refs.guess.value}!` default: prompt = "Guess a number between 1 and 100." }

return ( <div style={styles}> <h1>Guess The Number</h1> <p>{ prompt }</p>

<input ref="guess" type="text" /> <button type="submit">Guess</button> </div> )

}}


export default GuessNumber;

Raten

Das API-Modul von AWS Amplify gibt Ihnen die Möglichkeit, Anforderungen an Ihre Cloud Logic-APIsdirekt aus der JavaScript-Anwendung zu senden.

So tätigen Sie einen RESTful-API-Aufruf

20



1. Importieren Sie das API-Modul aus aws-amplify in die GuessNumber-Komponentendatei.

import { API } from 'aws-amplify';

2. Fügen Sie die makeGuess-Funktion hinzu. Diese Funktion verwendet die API-Funktion des post-Moduls zum Absenden eines Rateversuchs an die Cloud Logic-API.

async makeGuess() { const guess = parseInt(this.refs.guess.value); const body = { guess } const { result } = await API.post('Guesses', '/number', { body }); this.setState({ guess: result });}

3. Ändern Sie die Guess-Schaltfläche in der render-Funktion der Komponente, um die makeGuess-Funktion aufzurufen, wenn sie ausgewählt wird.

<button type="submit" onClick={this.makeGuess.bind(this)}>Guess</button>

Öffnen Sie Ihre App lokal und testen Sie das Erraten der Zahl, indem Sie awsmobile run ausführen.

Die gesamte Komponente sollte folgendermaßen aussehen:

// Number guessing game app example

import React from 'react';import { API } from 'aws-amplify';

class GuessNumber extends React.Component { state = { guess: null };

async makeGuess() { const guess = parseInt(this.refs.guess.value, 10); const body = { guess } const { result } = await API.post('Guesses', '/number', { body }); this.setState({ guess: result }); }

render() { let prompt = ""

switch (this.state.guess) { case "high": prompt = "Incorrect. Guess a lower number."; break; case "low": prompt = "Incorrect. Guess a higher number."; break; case "correct": prompt = `Correct! The number is ${this.refs.guess.value}!`; break; default: prompt = "Guess a number between 1 and 100."; }

return (

21


<div style={styles}> <h1>Guess The Number</h1> <p>{ prompt }</p>

<input ref="guess" type="text" /> <button type="submit" onClick={this.makeGuess.bind(this)}>Guess</button> </div> )

}}


export default GuessNumber;

Nächste Schritte

• Erfahren Sie, wie Sie mit dem API-Modul in AWS Amplify spezielle Elemente abrufen können und vielesmehr.

• Erfahren Sie, wie Sie mit der AWS Mobile CLI mehr Funktionen für Ihre App aktivieren können.• Weitere Informationen darüber, was hinter den Kulissen passiert, finden Sie im Artikel zum Einrichten von

Lambda und API-Gateway.

Hosten Ihrer Web-AppImportant


Themen• Informationen zum Hosting und Streaming (p. 22)• Verwalten Ihrer App-Komponenten (p. 23)• Konfigurieren einer benutzerdefinierten Domäne für Ihre Web-App (p. 24)

Informationen zum Hosting und Streaming

Wenn Sie Ihre Web-App erstmalig zur Cloud übertragen, wird die Funktion zum Hosting und Streamingaktiviert, um Ihre App statisch im Web zu hosten. Mit der AWS Mobile CLI gestaltet sich die erstmaligeAusführung folgendermaßen:

$ awsmobile publish

Mithilfe eines Amazon S3-Buckets wird ein Container für Ihren Inhalt erstellt. Der Inhalt ist im Internetöffentlich verfügbar und Sie können eine Vorversion des Inhalts mithilfe einer Test-URL direkt anzeigen.

Der im Bucket platzierte Inhalt wird automatisch an ein weltweites Netzwerk zur Bereitstellung von Inhalten,ein sogenanntes Content Delivery Network (CDN), verteilt. Amazon CloudFront implementiert das CDN,

22



https://alpha-docs-aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html

https://alpha-docs-aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html



https://docs.aws.amazon.com/AmazonS3/latest/dev/



das Ihre App weltweit auf einem Endpunkt nahe jedem Benutzer hosten kann. Diese Endpunkte könnenauch Medieninhalt streamen. Weitere Informationen finden Sie in den CloudFront-Streaming-Tutorials.

Die Funktion für Hosting und Streaming stellt standardmäßig eine einfache Web-App bereit, die auf AWS-Services zugreift.

Verwalten Ihrer App-Komponenten

Sie können den Inhalt Ihres Buckets mithilfe der AWS Mobile CLI oder der Amazon S3-Konsole verwalten.

Verwenden der AWS-CLI zum Verwalten des Inhalts Ihres Buckets

Die AWS-CLI ermöglicht Ihnen, in Ihrem Bucket gespeicherte Dateien mithilfe der Befehlszeile zu prüfen,hochzuladen, zu verschieben oder zu löschen. Informationen zur Installation und Konfiguration des AWSCLI-Clients finden Sie unter Einrichten mit der AWS-Befehlszeilenschnittstelle.

Beispielsweise können Sie mit dem sync-Befehl Dateien von Ihrem und in Ihren lokalen Ordner (source)sowie von Ihrem und in Ihren Bucket (destination) übertragen.

$ aws s3 sync {source destination} [--options]

Der folgende Befehl synchronisiert alle Dateien aus Ihrem aktuellen lokalen Ordner mit dem durch pathdefinierten Ordner im Bucket Ihrer Web-App.

$ aws s3 sync . s3://AWSDOC-EXAMPLE-BUCKET/path

Weitere Informationen über die Verwendung der AWS-CLI zum Verwalten von Amazon S3 finden Sie unterVerwenden von Amazon S3 mit der AWS-Befehlszeilenschnittstelle

Verwenden der Amazon S3 Console zum Verwalten Ihres Buckets

Um Ihre im Bucket gespeicherten Dateien mit der Amazon S3-Konsole zu überprüfen, hochzuladen, zuverschieben oder zu löschen, verfahren Sie wie folgt.

1. Führen Sie im Stammverzeichnis Ihres Projekts Folgendes aus:

awsmobile console

2. Wählen Sie die Kachel mit dem Namen Ihres Projekts und anschließend die Kachel für Hosting undStreaming aus.

3. Wählen Sie den Link Manage files (Dateien verwalten), um den Inhalt Ihres Buckets in der Amazon S3-Konsole anzuzeigen.

Weitere hilfreiche Funktionen in der AWS Mobile Hub-Konsole

Die Mobile Hub-Konsole bietet auch praktische Methoden zum Durchsuchen Ihres Webinhalts, zumZurückkehren zum AWS-CLI-Inhalt auf dieser Seite und zu anderen relevanten Aufgaben. Dazu zählen:

23

https://docs.aws.amazon.com/mobile-hub/latest/developerguide/url-cf-dev;Tutorials.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-s3.html


• Der Link View from S3 (Ansicht vom S3) navigiert zum Webinhalt Ihres Buckets. Wenn die Funktion fürdas Hosting und Streaming aktiviert ist, wird der Bucket automatisch mit den Dateien für eine Standard-Web-App ausgefüllt, die unverzüglich anzeigbar ist.

• Der Link View from CloudFront (Ansicht von CloudFont) navigiert zu den Webinhalten, dieautomatisch aus Ihrem Bucket auf das CDN übertragen wurden. Die Endpunkt-Verbreitung ist von denNetzwerkbedingungen abhängig. Sie können erwarten, dass Ihr Inhalt innerhalb einer Stunde verteilt wirdund anzeigbar ist.

• Über den Link Sync files with the command line (Dateien mit der Befehlszeile synchronisieren) gelangenSie zu dem Inhalt auf dieser Seite, der beschreibt, wie Sie die Web-App und Streaming-Mediendateien inIhrem Bucket über die Befehlszeile verwalten können.

Konfigurieren einer benutzerdefinierten Domäne für Ihre Web-App

Damit Sie Ihre benutzerdefinierte Domäne zum Verlinken auf Ihre Web-App verwenden können,konfigurieren Sie das DNS-Routing mithilfe des Route 53-Services.

Informationen zu Web-Apps, die an einem einzelnen Standort gehostet werden, finden Sie unterWeiterleiten von Datenverkehr an eine Website, die in einem Amazon S3-Bucket gehostet wird.

Informationen zu Web-Apps, die über ein globales CDN verteilt werden, finden Sie unter Weiterleiten desDatenverkehrs zu einer Amazon CloudFront-Webverteilung mithilfe des Domänennamens

AWS Mobile Hub-FunktionenImportant

Der folgende Inhalt trifft zu, wenn Sie bereits die AWS Mobile-CLI zum Konfigurieren IhresBackends verwenden. Wenn Sie eine neue mobile oder Web-App erstellen oder Cloud-Funktionenzu einer vorhandenen App hinzufügen, verwenden Sie stattdessen die neue AWS Amplify-CLI.

24

https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/RoutingToS3Bucket.html

https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-cloud-fron-distribution.html

https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-cloud-fron-distribution.html



Mit der neuen Amplify-CLI können Sie alle unter Ankündigung der AWS Amplify-CLI-Toolchainbeschriebenen Funktionen nutzen, einschließlich AWS CloudFormation-Funktionalität, diezusätzliche Workflows bereitstellt.

Die folgenden Seiten enthalten Referenzmaterial für die AWS Mobile-CLI für Web (JavaScript).

Themen• AWS Mobile CLI-Referenz (p. 25)• AWS Mobile CLI-Benutzeranmeldeinformationen (p. 35)• Protokollieren von AWS Mobile CLI-API-Aufrufen mit AWS CloudTrail (p. 37)

AWS Mobile CLI-ReferenzImportant


Die AWS Mobile CLI bietet eine Befehlszeilenschnittstelle für Frontend-JavaScript-Entwickler, um AWS-Services nahtlos zu aktivieren und in ihre Apps zu konfigurieren. Mit nur minimalem Konfigurationsaufwandkönnen Sie die gesamte Funktionalität nutzen, die vom AWS Mobile Hub aus dem von Ihnen bevorzugtenTerminal-Programm bereitgestellt wird.

Installation und Nutzung

Dieser Abschnitt beschreibt die Nutzung und Kernbefehle der awsmobile CLI für JavaScript.

Installieren Sie die AWS Mobile CLI.

1. Registrieren Sie sich für das kostenlose Kontingent für AWS.2. Installieren Sie Node.js mit NPM.3. Installieren Sie die AWS Mobile CLI.

npm install -g awsmobile-cli



awsmobile configure


Verwendung

Die Nutzung der AWS Mobile CLI ist darauf ausgelegt, anderen branchenüblichenBefehlszeilenschnittstellen zu entsprechen.

25




https://console.aws.amazon.com/mobilehub




awsmobile <command> [options]

Die Optionen help und version sind für alle Befehle allgemeingültig. Zusätzliche Sonderoptionen füreinige Befehle werden in den relevanten Abschnitten beschrieben.

-V, --version output the version number-h, --help output usage information

Beispiel:

awsmobile -helporawsmobile init --help

Übersicht der CLI-Befehle

Die aktuellen Befehle, die von der awsmobile CLI unterstützt werden, sind unten aufgeführt.

awsmobile init (p. 27) Initialisiert ein neues Mobile Hub-Projekt, suchtnach IAM-Schlüsseln und ruft die Datei "aws-exports.js" ab

awsmobile configure (p. 28) Zeigt vorhandene Schlüssel und ermöglichtderen Änderung, wenn sie bereits festgelegtsind. Wenn noch keine Schlüssel festgelegtsind, verknüpft Deep den Benutzer mit der IAM-Konsole, um Schlüssel zu erstellen, und fordertdann zur Eingabe des Zugriffs- und geheimenSchlüssels auf. Mit diesem Befehl können SieKonfigurationseinstellungen für das AWS-Kontooder Projekt bearbeiten.

awsmobile pull (p. 29) Lädt die neueste aws-exports.js, YAML oder jedesandere relevante Projektdetail aus dem MobileHub-Projekt herunter

awsmobile push (p. 29) Lädt lokale Metadaten, Lambda-Code, DynamoDB-Definitionen oder jedes andere relevanteProjektdetail auf Mobile Hub hoch

awsmobile publish (p. 29) Führt awsmobile push aus und erstellt undveröffentlicht anschließend die clientseitigeAnwendung in S3 und Cloud Front

awsmobile run (p. 30) Führt zunächst awsmobile push undanschließend den Startbefehl des Projekts aus,um einen Testlauf der clientseitigen Anwendungdurchzuführen

awsmobile console (p. 30) Öffnen Sie die Web-Konsole des Mobile-Hub-Projekts "awsmobile" im Standardbrowser

awsmobile features (p. 30) Zeigt verfügbare und aktivierte Funktionen an.Klicken Sie, um Funktionen zu aktivieren oder zudeaktivieren.

26


awsmobile <feature-name> enable [–prompt] (p. 30)

Aktiviert die Funktion mit den Standardwerten (undder Eingabeaufforderung für Änderungen).

awsmobile <feature-name> disable (p. 32) Deaktiviert die Funktion

awsmobile <feature-name> configure (p. 32) Enthält funktionsspezifische Unterbefehle wie "add-table", "add-api" usw.

awsmobile cloud-api invoke <apiname> <method><path> [init] (p. 34)

Ruft die API für lokales Testen auf. Dies unterstütztSie beim Schnelltest von vorzeichenlosen APIs inIhrer lokalen Umgebung.

awsmobile delete (p. 34) Löscht das Mobile Hub-Projekt.

awsmobile help [cmd] (p. 34) Zeigt Hilfe für [cmd] an.

init

Der Befehl awsmobile init initialisiert ein neues Mobile Hub-Projekt, sucht nach IAM-Schlüsseln undruft die Datei "aws-exports.js" ab.

Es stehen zwei Verwendungen des Befehls awsmobile init zur Verfügung

1. Initialisieren des aktuellen Projekts mit awsmobilejs-Funktionen

awsmobile init

Legen Sie nach Aufforderung diese Projektkonfigurationen fest:

Please tell us about your project:? Where is your project's source directory: src? Where is your project's distribution directory that stores build artifacts: build? What is your project's build command: npm run-script build? What is your project's start command for local test run: npm run-script start

? What awsmobile project name would you like to use: my-mobile-project

Die AWS Mobile CLI kopiert die neueste aws-exports.js in das Quellverzeichnis, damit sie fürIhren Frontend-Code problemlos bereitgestellt werden kann. Diese Datei wird immer dann automatischaktualisiert, wenn Funktionen hinzugefügt oder entfernt werden. Bei Angabe eines falschen/nichtverfügbaren Ordners wird die Datei nicht kopiert.

Die Verteilung ist im Wesentlichen das Build-Verzeichnis für Ihr Projekt. Dies wird während desawsmobile publish-Prozesses verwendet.

Die Build- und Startwerte des Projekts werden entsprechend der Befehle awsmobile publish undawsmobile run verwendet.

Der Name des awsmobile-Projekts ist der Name des Backend-Projekts, das im Mobile Hub erstelltwurde.

Sie können die Einstellungen für das Projekt ändern, indem Sie den Befehl awsmobile configureproject (p. 28) verwenden.

2. Initialisieren und Verknüpfen mit einem vorhandenen awsmobile-Projekt als Backend

awsmobile init <awsmobile-project-id>

27


Die ID des awsmobile-Projekts ist die ID des vorhandenen Backend-Projekts im Mobile Hub. DieserBefehl fügt Ihrer App ein vorhandenes Backend-Projekt an.

3. Entfernen des angefügten awsmobile-Projekts aus dem Backend.

awsmobile init --remove

Dieser Befehl entfernt das angefügte Backend-Projekt, das mit Ihrer App verknüpft ist, und bereinigtdie verknüpften Dateien. Dies ändert Ihre App in keiner Weise, außer dass das Backend-Projekt selbstentfernt wird.

configure

Der awsmobile configure zeigt vorhandene Schlüssel und ermöglicht deren Änderung, wenn siebereits festgelegt sind. Wenn noch keine Schlüssel festgelegt sind, verknüpft Deep den Benutzer mitder IAM-Konsole, um Schlüssel zu erstellen, und fordert dann zur Eingabe des Zugriffs- und geheimenSchlüssels auf. Dazu stehen zwei mögliche Verwendungen dieses Befehls zur Verfügung. Dieser Befehlkann basierend auf dem ausgewählten Argument verwendet werden, um die AWS-KontoeinstellungenODER die Projekteinstellungen festzulegen oder zu ändern.

awsmobile configure [aws|project]

1. Konfigurieren der AWS-Kontoeinstellungen mithilfe des aws-Arguments. Dies ist das Standardargumentfür diesen Befehl

awsmobile configureorawsmobile configure aws

Sie werden Fragen beantworten müssen, um die AWS-Kontoanmeldeinformationen wie folgt festzulegen

configure aws? accessKeyId: <ACCESS-KEY-ID>? secretAccessKey: <SECRET-ACCESS-KEY>? region: <SELECT-REGION-FROM-THE-LIST>

2. Konfigurieren der Projekteinstellungen mithilfe des project-Arguments

awsmobile configure project

Sie werden Fragen beantworten müssen, um das Projekt wie nachfolgend beschrieben zu konfigurieren

? Where is your project's source directory: src? Where is your project's distribution directory to store build artifacts: dist? What is your project's build command: npm run-script build? What is your project's start command for local test run: npm run-script start

3. Abrufen und Anzeigen der AWS-Anmeldeinformationen mithilfe der --list-Option

awsmobile configure --list

28


pull

Der Befehl awsmobile pull lädt die neueste aws-exports.js, YAML und jedes relevante Cloud-/Backend-Artefakt vom Mobile Hub-Projekt in die lokale Entwicklungsumgebung herunter. Verwenden Sie diesenBefehl, wenn Sie das Projekt im Mobile Hub geändert haben und das Neueste in Ihrer lokalen Umgebungabrufen möchten.

awsmobile pull

push

Der awsmobile push lädt lokale Metadaten, Lambda-Code, Dynamo-Definitionen und jedes relevanteArtefakt auf Mobile Hub hoch. Verwenden Sie diesen Befehl, wenn Sie Funktionen in Ihrer lokalenUmgebung aktivieren, deaktivieren oder konfigurieren und das Backend-Projekt im Mobile Hub mit denrelevanten Updates aktualisieren möchten.

awsmobile push

Verwenden Sie awsmobile push, nach awsmobile features, awsmobile <feature> enable,awsmobile <feature> disable oder awsmobile <feature> configure, um das Backend-Projekt ordnungsgemäß zu aktualisieren. Dies kann verwendet werden, nachdem entweder jede dieserÄnderungen oder sobald alle diese Änderungen lokal vorgenommen wurden.

publish

Der Befehl awsmobile publish führt zuerst den awsmobile-Befehl push aus, erstellt anschließend denclientseitigen Code und veröffentlicht ihn im Amazon S3-Hosting-Bucket. Dieser Befehl veröffentlicht dieClient-Anwendung für das Hosten im s3-Bucket und öffnet anschließend den Browser, um die Indexseiteanzuzeigen. Er prüft die Zeitstempel, um die App bei Bedarf vor der Bereitstellung automatisch zu erstellen.Er prüft, ob der Client das Hosten in den Backend-Projektfunktionen ausgewählt hat, und falls nicht, forderter den Client auf, das Backend mit der Hosting-Funktion zu aktualisieren.

awsmobile publish

Der publish-Befehl verfügt über eine Reihe von Optionen, die verwendet werden können.

1. Aktualisieren der Cloud Front-Verteilungen

awsmobile publish -c orawsmobile publish --cloud-front

2. Testen der Anwendung in AWS Device Farm

awsmobile publish -torawsmobile publish --test

3. Unterdrücken der Tests in AWS Device Farm

awsmobile publish -n

4. Veröffentlichen des Frontends ausschließlich ohne Aktualisierung des Backends

awsmobile publish -forawsmobile publish --frontend-only

29


run

Der Befehl awsmobile run führt zuerst den Befehl awsmobile push aus und anschließend wird derStartbefehl ausgeführt, den Sie in der Projektkonfiguration festgelegt haben, wie z. B. npm run startoder npm run ios. Damit können Sie einen Testlauf Ihrer Anwendung mit der neuesten in die Cloudhochgeladenen Backend-Entwicklung bequem lokal durchführen.

awsmobile run

console

Der Befehl awsmobile console öffnet die Web-Konsole des Mobile Hub-Projekts "awsmobile" imStandardbrowser

awsmobile console

Funktionen

Der Befehl awsmobile features zeigt alle verfügbaren awsmobile-Funktionen an und ermöglicht Ihnen,diese einzeln lokal zu aktivieren/deaktivieren. Nutzen Sie die Pfeiltaste zum Hoch- und Runterscrollen unddie Leertaste, um jede Funktion zu aktivieren/deaktivieren. Bitte beachten Sie, dass die Änderungen nurlokal vorgenommen werden. Führen Sie den Befehl "awsmobile push" aus, um das awsmobile-Projekt inder Cloud zu aktualisieren.

awsmobile features

Die von der AWS Mobile CLI unterstützten Funktionen sind:

• user-signin (Amazon Cognito)• user-files (Amazon S3)• cloud-api (Lambda / API Gateway)• database (DynamoDB)• analytics (Amazon Pinpoint)• hosting (Amazon S3 and CloudFront)

? select features: (Press <space> to select, <a> to toggle all, <i> to inverse selection)## user-signin # user-files # cloud-api # database # analytics # hosting

Seien Sie beim Deaktivieren einer Funktion vorsichtig. Das Deaktivieren einer Funktion löscht allezugehörigen Objekte (APIs, Lambda-Funktionen, Tabellen usw.). Diese Artefakte können lokal nichtwiederhergestellt werden, auch wenn Sie diese Funktion erneut aktivieren.

Verwenden Sie awsmobile push, nach awsmobile <feature> disable, um das Backend-Projekt imAWS Mobile Hub-Projekt mit den ausgewählten Funktionen zu aktualisieren.

enable

Der awsmobile <feature> enable aktiviert die angegebene Funktion mit den Standardeinstellungen.Bitte beachten Sie, dass die Änderungen nur lokal vorgenommen werden. Führen Sie den Befehl"awsmobile push" aus, um das AWS Mobile-Projekt in der Cloud zu aktualisieren.

30


awsmobile <feature> enable


• user-signin (Amazon Cognito)• user-files (Amazon S3)• cloud-api (Lambda / API Gateway)• database (DynamoDB)• analytics (Amazon Pinpoint)• hosting (Amazon S3 and CloudFront)

Der Unterbefehl awsmobile <feature> enable --prompt ermöglicht es dem Benutzer, die Detailsder zu aktivierenden Mobile Hub-Funktion festzulegen, anstatt die Standardeinstellungen zu verwenden. Erfordert den Benutzer auf, eine Liste von Fragen zu beantworten, um die Funktion ausführlich festzulegen.

awsmobile <feature> enable -- prompt

Die Aktivierung der user-signin-Funktion fordert Sie auf, die Art und Weise zu ändern, wie sieaktiviert wird, erweiterte Einstellungen für das Projekt zu konfigurieren oder dessen Anmeldefunktion zudeaktivieren. Durch die Auswahl der gewünschten Option könnten weitere Fragen angezeigt werden.

awsmobile user-signin enable --prompt

? Sign-in is currently disabled, what do you want to do next (Use arrow keys)# Enable sign-in with default settings Go to advance settings

Das Aktivieren der user-files-Funktion mit der Option --prompt fordert Sie auf, die Nutzung von S3-Benutzerdaten zu bestätigen.

awsmobile user-files enable --prompt

? This feature is for storing user files in the cloud, would you like to enable it? Yes

Das Aktivieren der cloud-api-Funktion mit der Option --prompt fordert Sie auf, eine mit dem Projektverbundene API zu erstellen, zu entfernen oder zu bearbeiten. Durch die Auswahl der gewünschten Optionkönnten weitere Fragen angezeigt werden.


? Select from one of the choices below. (Use arrow keys) # Create a new API

Das Aktivieren der database-Funktion mit der Option --prompt zeigt Ihnen erste Fragen an, um IhreDatenbanktabellendetails, die mit dem Projekt verbunden sind, anzugeben. Durch die Auswahl dergewünschten Option könnten weitere Fragen angezeigt werden.


? Should the data of this table be open or restricted by user? (Use arrow keys)# Open Restricted

31


Das Aktivieren der analytics-Funktion mit der Option --prompt fordert Sie auf, die Nutzung vonPinpoint Analytics zu bestätigen.

awsmobile analytics enable --prompt

? Do you want to enable Amazon Pinpoint analytics? (y/N)

Das Aktivieren der hosting-Funktion mit der Option --prompt fordert Sie auf, das Hosten und Streamenauf der CloudFront-Verteilung zu bestätigen.

awsmobile hosting enable --prompt

? Do you want to host your web app including a global CDN? (y/N)

Führen Sie awsmobile push aus, nachdem Sie awsmobile <feature> enable verwendet haben, umdas awsmobile-Projekt in der Cloud zu aktualisieren.

disable

Der Befehl awsmobile <feature> disable deaktiviert die Funktion in Ihrem Backend-Projekt. SeienSie beim Deaktivieren einer Funktion vorsichtig. Das Deaktivieren einer Funktion löscht alle zugehörigenObjekte (APIs, Lambda-Funktionen, Tabellen usw.). Diese Artefakte können lokal nicht wiederhergestelltwerden, auch wenn Sie diese Funktion erneut aktivieren.

awsmobile <feature> disable


• user-signin (Amazon Cognito)• user-files (Amazon S3)• cloud-api (Lambda / API Gateway)• database (DynamoDB)• analytics (Amazon Pinpoint)• hosting `

Verwenden Sie awsmobile push, nach awsmobile <feature> disable, um das Backend-Projekt imAWS Mobile Hub-Projekt mit den deaktivierten Funktionen zu aktualisieren.

configure

Der Befehl awsmobile <feature> configure konfiguriert die Objekte in der ausgewählten Funktion.Die Konfiguration könnte bedeuten, dass ein bestimmtes Artefakt hinzugefügt, gelöscht oder aktualisiertwird. Dieser Befehl kann ausschließlich verwendet werden, wenn die spezifische Funktion bereits aktiviertist.

awsmobile <feature> configure


• user-signin (Amazon Cognito)• user-files (Amazon S3)• cloud-api (Lambda / API Gateway)• database (DynamoDB)

32


• analytics (Amazon Pinpoint)• hosting (Amazon S3 and CloudFront)

Das Konfigurieren der user-signin-Funktion fordert Sie auf, die Art und Weise zu ändern, wie sieaktiviert wird, erweiterte Einstellungen für das Projekt zu konfigurieren oder dessen Anmeldefunktion zudeaktivieren. Durch die Auswahl der gewünschten Option könnten weitere Fragen angezeigt werden.

awsmobile user-signin configure

? Sign-in is currently enabled, what do you want to do next (Use arrow keys)# Configure Sign-in to be required (Currently set to optional) Go to advance settings Disable sign-in

Das Konfigurieren der user-files-Funktion fordert Sie auf, die Nutzung von S3-Benutzerdaten zubestätigen.

awsmobile user-files configure

? This feature is for storing user files in the cloud, would you like to enable it? (Y/n)

Das Konfigurieren der cloud-api-Funktion fordert Sie auf, eine mit dem Projekt verbundene API zuerstellen, zu entfernen oder zu bearbeiten. Durch die Auswahl der gewünschten Option könnten weitereFragen angezeigt werden.

awsmobile cloud-api configure

? Select from one of the choices below. (Use arrow keys)# Create a new API Remove an API from the project Edit an API from the project

Das Konfigurieren der database-Funktion fordert Sie auf, eine mit dem Projekt verbundene Tabelle zuerstellen, zu entfernen oder zu bearbeiten. Durch die Auswahl der gewünschten Option könnten weitereFragen angezeigt werden.

awsmobile database configure

? Select from one of the choices below. (Use arrow keys) # Create a new table Remove table from the project Edit table from the project

Das Konfigurieren der analytics-Funktion fordert Sie auf, die Nutzung von Pinpoint Analytics zubestätigen.

awsmobile analytics configure

? Do you want to enable Amazon Pinpoint analytics? Yes

Das Konfigurieren der hosting-Funktion fordert Sie auf, das Hosten und Streamen auf der CloudFront-Verteilung zu bestätigen.

awsmobile hosting configure

? Do you want to host your web app including a global CDN? Yes

33


Verwenden Sie awsmobile push, nach awsmobile <feature> configure, um das Backend-Projektim AWS Mobile Hub-Projekt mit den konfigurierten Funktionen zu aktualisieren.

invoke

Der Befehl awsmobile cloud-api invoke ruft die API für lokales Testen auf. Damit können Sievorzeichenlose APIs schnell lokal testen, indem Sie die entsprechenden Argumente übergeben. Dies ist fürdie Verwendung der Entwicklungsumgebung oder das Debugging Ihrer API-/Lambda-Funktion vorgesehen.

awsmobile cloud-api invoke <apiname> <method> <path> [init]

Sie könnten beispielsweise die sampleCloudApi-post-Methode wie unten gezeigt aufrufen

awsmobile cloud-api invoke sampleCloudApi post /items '{"body":{"test-key":"test-value"}}'

Der obige Test gibt einen Wert zurück, der aussieht wie

{ success: 'post call succeed!', url: '/items', body: { 'test-key': 'test-value' } }

Gleichermaßen könnten Sie beispielsweise die sampleCloudApi-get-Methode wie unten gezeigt aufrufen

awsmobile cloud-api invoke sampleCloudApi get /items

Der obige Test gibt einen Wert zurück, der aussieht wie

{ success: 'get call succeed!', url: '/items' }

delete

Der Befehl awsmobile delete löscht das Mobile Hub-Projekt in der Cloud. Seien Sie besondersvorsichtig, wenn Sie sich dazu entscheiden, diesen Befehl auszuführen, da er sich unwiderruflich auf dieArbeit Ihres Teams auswirken kann. Das Mobile Hub-Projekt wird gelöscht und kann nicht wiederhergestelltwerden, sobald der Befehl ausgeführt wird.

awsmobile delete

help

Der Befehl awsmobile help kann als Standalone-Befehl verwendet werden oder es kann derBefehlsname, bei dem Sie Hilfe benötigen, als Argument übergeben werden. Dadurch werden dieNutzungsinformationen für diesen Befehl zur Verfügung gestellt, einschließlich aller Optionen, die mitdiesem verwendet werden können.

Beispiel:

awsmobile helporawsmobile help init

Die Option --help, die am Anfang dieser Seite erläutert wird, und der Befehl awsmobile help bietendieselbe Detailstufe. Der Unterschied besteht in der Verwendung.

34


AWS Mobile CLI-BenutzeranmeldeinformationenImportant


Übersicht

Wenn Sie die CLI erstmalig einrichten, werden Sie zur Eingabe von AWS-Anmeldeinformationenaufgefordert. Die Anmeldeinformationen legen fest, welche Berechtigungen die CLI erhält, umAWS-Services in Ihrem Namen zu verwalten. Sie müssen zu einem AWS IAM-Benutzer mitAdministratorberechtigungen in dem Konto gehören, in dem die CLI verwendet wird.

Berechtigungen

Administratorberechtigungen werden von einem AWS-Kontoadministrator erteilt. Wenn Sie keineAdministratorberechtigungen besitzen, müssen Sie einen Administrator des AWS-Kontos bitten, diese zugewähren.

Wenn Sie der Kontobesitzer sind und sich mit den Root-Anmeldeinformationen des Kontos angemeldethaben, verfügen Sie über Administratorberechtigungen bzw. können sich diese mit der verwaltetenRichtlinie AdministratorAccess selbst gewähren. Es hat sich bewährt, für den Zugriff auf AWS-Services einen neuen IAM-Benutzer im Konto zu erstellen und nicht die Root-Anmeldeinformationen zuverwenden.

Weitere Informationen finden Sie unter Kontrollieren des Zugriffs auf Mobile Hub-Projekte (p. 83).

Abrufen der Anmeldeinformationen eines Kontobenutzers

Wenn Sie über Administratorberechtigungen verfügen, müssen Sie in der CLI die Zugriffsschlüssel-ID undden geheimen Zugriffsschlüssel des IAM-Benutzers angeben. Falls nicht, müssen Sie sich diese Werte voneinem Administrator besorgen.

Um ID und Schlüssel in der AWS-CLI anzugeben, führen Sie die Schritte zum Anmelden bei AWS durchund geben Benutzername und AWS-Region an. Die CLI öffnet dann das Dialogfeld Add user (Benutzerhinzufügen) der AWS IAM-Konsole. Die Richtlinie AdministratorAccess ist zugeordnet und die OptionProgrammatic access (Programmgesteuerter Zugriff) standardmäßig aktiviert.

Themen• Abrufen von Anmeldeinformationen für einen neuen Benutzer (p. 35)• Abrufen der Anmeldeinformationen eines vorhandenen Benutzers (p. 36)

Abrufen von Anmeldeinformationen für einen neuen Benutzer

1. Klicken Sie auf Next: Permissions (Nächster Schritt: Berechtigungen) und dann auf Create user(Benutzer erstellen).

Alternativ können Sie den Benutzer auch einer Gruppe mit zugeordneter AdministratorAccess-Richtlinie hinzufügen.

35



https://console.aws.amazon.com/iam/


2. Wählen Sie Create user aus.3. Kopieren Sie die Werte in der angezeigten Tabelle oder klicken Sie auf Download .csv (CSV-Datei

herunterladen), um die Werte lokal zu speichern und anschließend an den Eingabeaufforderungeneinzugeben.

Nähere Informationen finden Sie unter Hinzufügen eines neuen Kontobenutzers mitAdministratorberechtigungen (p. 84).

Abrufen der Anmeldeinformationen eines vorhandenen Benutzers

1. Klicken Sie auf Cancel (Abbrechen).

36


2. Klicken Sie im linken Bereich auf Users (Benutzer) und wählen Sie den gewünschten Benutzer in derListe aus. Klicken Sie auf Security credentials (Sicherheitsanmeldeinformationen) und danach auf Createaccess key (Zugriffsschlüssel erstellen).

Protokollieren von AWS Mobile CLI-API-Aufrufen mit AWS CloudTrailImportant


Die AWS Mobile-CLI ist in AWS CloudTrail integriert. Dies ist ein Service, der die Aktionen eines Benutzers,einer Rolle oder eines AWS-Services in der CLI aufzeichnet. CloudTrail erfasst alle API-Aufrufe für die CLIals Ereignisse, einschließlich Aufrufen von Code-Aufrufen an die CLI-APIs. Wenn Sie einen Trail erstellen,aktivieren Sie die kontinuierliche Bereitstellung von CloudTrail-Ereignissen an einen Amazon S3-Bucket,einschließlich Ereignissen für CLI. Auch wenn Sie keinen Trail konfigurieren, können Sie die neuestenEreignisse in der CloudTrail-Konsole unter Event history (Ereignisverlauf) anzeigen. Mit den von CloudTrailgesammelten Informationen können Sie die an CLI gestellte Anfrage, die IP-Adresse, von der die Anfragegestellt wurde, den Initiator der Anfrage, den Zeitpunkt der Anfrage und weitere Angaben bestimmen.

Weitere Informationen zu CloudTrail finden Sie im AWS CloudTrail-Benutzerhandbuch.

AWS Mobile CLI-Informationen in CloudTrail

CloudTrail wird beim Erstellen Ihres AWS-Kontos für Sie aktiviert. Die in der AWS Mobile-CLI auftretendenAktivitäten werden zusammen mit anderen AWS-Serviceereignissen im Bereich Event history(Ereignisverlauf) in einem CloudTrail-Ereignis erfasst. Sie können die neusten Ereignisse in Ihrem AWS-Konto anzeigen, suchen und es dorthin herunterladen. Weitere Informationen finden Sie unter Anzeigenvon Ereignissen mit dem CloudTrail-Ereignisverlauf.

Erstellen Sie einen Pfad für einen fortlaufenden Datensatz zu Ereignissen in Ihrem AWS-Konto,einschließlich Ereignissen für AWS Mobile CLI. Ein Trail ermöglicht CloudTrail die Übermittlung vonProtokolldateien an einen Amazon S3-Bucket. Wenn Sie einen Pfad in der Konsole anlegen, gilt dieserstandardmäßig für alle Regionen. Der Pfad protokolliert Ereignisse aus allen Regionen in der AWS-Partitionund stellt die Protokolldateien in dem Amazon S3-Bucket bereit, den Sie angeben. Darüber hinaus könnenSie andere AWS-Services konfigurieren, um die in den CloudTrail-Protokollen erfassten Ereignisdatenweiter zu analysieren und entsprechend zu agieren. Weitere Informationen finden Sie unter:

• Übersicht zum Erstellen eines Pfads• Siehe Von CloudTrail unterstützte Services und Integrationen.• Konfigurieren von Amazon SNS-Benachrichtigungen für CloudTrail• Empfangen von CloudTrail-Protokolldateien aus mehreren Regionen und Empfangen von CloudTrail-

Protokolldateien von mehreren Konten.

Alle AWS Mobile CLI-Aktionen werden von CloudTrail protokolliert und in den AWS Mobile CLI-API-Referenzen (p. 25) dokumentiert. Zum Beispiel generieren Aufrufe von awsmobile init, awsmobilepull und awsmobile push Einträge in den CloudTrail-Protokolldateien.

Jedes Event oder jeder Protokolleintrag enthält Informationen über den Ersteller der Anfrage. Anhand derIdentitätsinformationen zur Benutzeridentität können Sie Folgendes bestimmen:

• Ob die Anfrage mit Root- oder AWS Identity and Access Management-Benutzeranmeldeinformationen(IAM) ausgeführt wurde.

37



https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/view-cloudtrail-events.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-create-and-update-a-trail.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-aws-service-specific-topics.html#cloudtrail-aws-service-specific-topics-integrations

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/receive-cloudtrail-log-files-from-multiple-regions.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-receive-logs-from-multiple-accounts.html

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchReact Native

• Ob die Anfrage mit temporären Sicherheitsanmeldeinformationen für eine Rolle oder einen föderiertenBenutzer ausgeführt wurde.

• Ob die Anforderung von einem anderen AWS-Service getätigt wurde.

Weitere Informationen finden Sie unter dem CloudTrail userIdentity-Element.

Grundlagen zu AWS Mobile CLI-Protokolldateieinträgen

Ein Trail ist eine Konfiguration, durch die Ereignisse an den von Ihnen angegebenen Amazon S3-Bucket übermittelt werden. CloudTrail-Protokolldateien können einen oder mehrere Einträge enthalten.Ein Ereignis stellt eine einzelne Anfrage aus einer beliebigen Quelle dar und enthält unter anderemInformationen über die angeforderte Aktion, das Datum und die Uhrzeit der Aktion sowie über dieAnfrageparameter. CloudTrail-Protokolldateien sind kein geordnetes Stacktrace der öffentlichen API-Aufrufe und erscheinen daher nicht in einer bestimmten Reihenfolge.

Das folgende Beispiel zeigt einen CloudTrail-Protokolleintrag, der die Aktion ListProjects demonstriert.

{ "eventVersion": "1.05", "userIdentity": { "type": "IAMUser", "principalId": "ABCDEFGHIJK0123456789", "arn": "arn:aws:iam::012345678901:user/Administrator", "accountId": "012345678901", "accessKeyId": "ABCDEFGHIJK0123456789", "userName": "YOUR_ADMIN_USER_NAME" }, "eventTime": "2017-12-18T23:10:13Z", "eventSource": "mobilehub.amazonaws.com", "eventName": "ListProjects", "awsRegion": "us-west-2", "sourceIPAddress": "111.111.111.111", "userAgent": "aws-cli/1.11.140 Python/2.7.13 Darwin/15.6.0 botocore/1.6.7 ", "requestParameters": { "maxResults": 0 }, "responseElements": { "projects": [{ "name": "YOUR_PROJECT_NAME-0123456789012", "projectId": "abcd0123-0123-0123-0123-abcdef012345" }] }, "requestID": "abcd0123-0123-0123-0123-abcdef012345", "eventID": "abcd0123-0123-0123-0123-abcdef012345", "eventType": "AwsApiCall", "recipientAccountId": "012345678901"}

AWS Amplify-Bibliothek für React NativeImportant


AWS Amplify ist eine Open-Source-JavaScript-Bibliothek für Frontend-Entwickler und Entwickler mobilerApps, die Cloud-fähige Anwendungen erstellen. Die Bibliothek ist eine deklarative Schnittstelle vieler

38

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-event-reference-user-identity.html





unterschiedlicher Kategorien von Vorgängen, um das Hinzufügen häufiger Aufgaben zu Ihrer Anwendungzu vereinfachen. Die Standardimplementierung funktioniert mit Amazon Web Services (AWS)-Ressourcen,wurde jedoch offen und Plug-in-fähig konzipiert, für die Verwendung mit anderen Cloud-Services, die eineImplementierung oder benutzerdefinierte Backends bereitstellen möchten.

Die AWS Mobile CLI, die auf AWS Mobile Hub basiert, bietet eine Befehlszeilenschnittstelle für Frontend-JavaScript-Entwickler, um AWS-Services nahtlos zu aktivieren und in ihre Apps zu konfigurieren. Mit nurminimalem Konfigurationsaufwand können Sie die gesamte Funktionalität nutzen, die von AWS Mobile Hubaus der von Ihnen bevorzugten Terminal-Anwendung bereitgestellt wird.

Themen• Loslegen (p. 39)• AWS Mobile Hub-Funktionen (p. 53)

LoslegenImportant


ÜbersichtDie AWS Mobile CLI bietet eine Befehlszeilenschnittstelle für Frontend-JavaScript-Entwickler, um schnellAWS-Backend-Ressourcen zu erstellen und in ihre mobilen Apps zu integrieren.

Voraussetzungen

1. Melden Sie sich für das kostenlose AWS-Nutzungskontingent an, damit Sie zu geringen Kosten oderkostenlos lernen und ausprobieren können.

2. Installieren Sie Node.js mit NPM.3. Installieren Sie die AWS Mobile CLI.

npm install --global awsmobile-cli



awsmobile configure



Sie müssen schnell eine React Native-Beispiel-App erstellen? Weitere Informationen finden Sie unterErstellen einer React Native-App.

39





https://facebook.github.io/react-native/docs/getting-started.html


So konfigurieren Sie Backend-Funktionen für Ihre App


awsmobile init

Mit dem Befehl init erstellen Sie ein Backend-Projekt für Ihre App. Standardmäßig sind Analysenund Web-Hosting in Ihrem Backend aktiviert und die Konfiguration wird in der App beim Initialisierenautomatisch geöffnet.

2. Wenn Sie dazu aufgefordert werden, geben Sie das Quellverzeichnis für Ihr Projekt an. Die CLI erzeugtan diesem Speicherort die Datei aws-exports.js. Sie enthält die Konfiguration und Endpunkt-Metadaten, die zum Verknüpfen Ihrer Frontend- mit Ihren Backend-Services verwendet werden.

? Where is your project's source directory: /

Geben Sie auf Aufforderung folgende Werte ein:

Please tell us about your project:? Where is your project's source directory: /? Where is your project's distribution directory that stores build artifacts: build? What is your project's build command: npm run-script build? What is your project's start command for local test run: npm run-script start

Herstellen einer Verbindung mit Ihrem BackendAWS Mobile verwendet die Open Source-Bibliothek AWS Amplify, um Ihren Code mit den für Ihre Appkonfigurierten AWS-Funktionen zu verknüpfen.

So verbinden Sie die App mit Ihren konfigurierten AWS-Services

1. Installieren Sie AWS Amplify für die React Native-Bibliothek.

npm install --save aws-amplify

2. Fügen Sie in App.js (oder anderem Code, der zur Startzeit ausgeführt wird), die folgenden Importehinzu.

import Amplify from 'aws-amplify';

import aws_exports from './YOUR-PATH-TO/aws-exports';

3. Fügen Sie dann den folgenden Code hinzu.

Amplify.configure(aws_exports);

Lokales Ausführen der App

Sie können Ihre App nun starten und die von AWS Mobile konfigurierten Standard-Services verwenden.

So starten Sie die App lokal

Verwenden Sie den nativen Befehl für die verwendeten React Native-Tools. Wenn Sie Ihre Appbeispielsweise mit create-react-native-app erstellt haben, führen Sie den folgenden Befehl aus:

npm run android

40

https://github.com/aws/aws-amplify


# OR

npm run ios

Bei jedem Start der App werden Nutzungsanalysen erfasst und können in der AWS-Konsole angezeigtwerden (p. 41).

Kostenloses Kontingent für AWS Wenn Sie die App über die CLI initialisieren oderüber die CLI Funktionen hinzufügen, werdenAWS-Services in Ihrem Namen konfiguriert.Die Preise für AWS Mobile-Services sind sokonzeptioniert, dass Sie mit dem kostenlosenAWS-Nutzungskontingent zu geringen Kosten oderkostenlos lernen und ausprobieren können.

Nächste Schritte

Hinzufügen von Funktionen

Fügen Sie mithilfe der CLI Ihrer mobilen App die folgenden AWS Mobile-Funktionen hinzu.

• Analysen (p. 41)• Benutzeranmeldung (p. 43)• NoSQL-Datenbank (p. 44)• User File Storage (p. 49)• Cloud Logic (p. 51)

Weitere Informationen

Weitere Informationen zu den Befehlen und der Nutzung der AWS Mobile CLI finden Sie in der AWS MobileCLI-Referenz (p. 25).


Hinzufügen von AnalysenImportant


Aktivierung des Backend für einfache Analysen in der App


41

https://aws.amazon.com/mobile/pricing







Nach Abschluss der Einrichtung von AWS Mobile CLI und dem Starten der App fließen anonymisiertedemografische Sitzungs- und Gerätedaten zum AWS-Analyse-Backend.

So senden Sie einfache Analysen der App-Nutzung an AWS

Starten Sie Ihre App lokal: Wenn Sie die App beispielsweise mit create-react-native-app erstellthaben, führen Sie Folgendes aus:

npm run android

# Or

npm run ios

Wenn Sie die App verwenden, erfasst und visualisiert der Amazon Pinpoint-Service Analysedaten.

So zeigen Sie die Analysen mit der Amazon Pinpoint-Konsole an

1. Starten Sie die App mindestens einmal.2. Öffnen Sie das Projekt in der AWS Mobile Hub-Konsole.

awsmobile console

3. Wählen Sie auf der linken Seite das Symbol Analytics (Analysen) aus, um in der Amazon Pinpoint-Konsole zu Ihrem Projekt zu navigieren.

4. Wählen Sie auf der linken Seite Analytics (Analysen) aus.

Sie sollten eine steigende Tendenz in mehreren Diagrammen sehen.

Hinzufügen von benutzerdefinierten Analysen zur App

Sie können die App so konfigurieren, dass Amazon Pinpoint Daten für benutzerdefinierte Ereignissesammelt, die im Codefluss registriert sind.

So nutzen Sie benutzerdefinierte Analysen in der App

Fügen Sie der Datei, die das zu verfolgende Ereignis enthält, folgenden Import hinzu:

import { Analytics } from 'aws-amplify';

Fügen Sie an der Stelle im JavaScript, an der das verfolgte Ereignis ausgelöst werden soll, einen Aufruf wieden folgenden ein:

componentDidMount() { Analytics.record('FIRST-EVENT-NAME');}

Oder auf relevante Seitenelemente:

handleClick = () => { Analytics.record('SECOND-EVENT-NAME');}

<Button title="Record event" onPress={this.handleClick}/>

So können Sie dies testen:

42







1. Speichern Sie die Änderungen und starten Sie die App. Verwenden Sie die App, sodass verfolgteEreignisse ausgelöst werden.

2. Wählen Sie in der Amazon Pinpoint-Konsole oben die Option Events (Ereignisse) aus.3. Wählen Sie links im Dropdown-Menü Event (Ereignis) ein Ereignis aus.

Benutzerdefinierte Ereignisdaten werden nach wenigen Minuten in der Konsole angezeigt.

Nächste Schritte

Erfahren Sie mehr zu den Analysen in AWS Mobile, die Teil der Funktion für Messaging undAnalysen (p. 63) sind. Diese Funktion verwendet Amazon Pinpoint.


Erfahren Sie mehr über AWS Amplify für die React Native-Bibliothek.

Hinzufügen einer Authentifizierungs-/BenutzeranmeldungImportant




Die AWS Mobile CLI-Komponenten für Benutzerauthentifizierung umfassen eine umfangreiche,konfigurierbare Benutzeroberfläche für die Registrierung und Anmeldung.

So aktivieren Sie die Authentifizierungsfunktionen


awsmobile user-signin enable

awsmobile push


Die AWS Mobile CLI ermöglicht Ihnen das Integrieren einer fertigen Registrierungs-/Anmelde-/Abmeldebenutzeroberfläche mithilfe der Befehlszeile.

So fügen Sie eine Benutzerauthentifizierungsbenutzeroberfläche zu Ihrer App hinzu

1. Installieren Sie AWS Amplify für die React Native-Bibliothek.

npm install --save aws-amplify

43







npm install --save aws-amplify-react-native

Hinweis Wenn Ihre React Native-App nicht mithilfe voncreate-react-native-app oder mit einerfrüheren Expo-Version als v25.0.0 (die Enginehinter create-react-native-app) erstelltwurde, müssen Sie Bibliotheken in Ihrem Projektfür das Auth-Modul auf React Native, amazon-cognito-identity-js, verknüpfen.

Um das Modul zu verknüpfen, müssen Sie dasProjekt zunächst auswerfen:

npm run ejectreact-native link amazon-cognito-identity-js

1. Fügen Sie App.js (oder einer anderen Datei, die beim Start der App aufgerufen wird) den folgendenImport hinzu:

import { withAuthenticator } from 'aws-amplify-react-native';

2. Ändern Sie dann export default App; wie folgt.

export default withAuthenticator(App);

Führen Sie zum Testen npm start oder awsmobile run aus.

Nächste Schritte

Erfahren Sie mehr über die Funktion für die Benutzeranmeldung (p. 72) von AWS Mobile, die AmazonCognito verwendet.



Zugriff auf Ihre DatenbankImportant




44







Die AWS Mobile database-Funktion ermöglicht es Ihnen, an Ihre Bedürfnisse angepasste Tabellen zuerstellen. Die CLI leitet Sie dann durch das Erstellen einer benutzerdefinierten API für den Zugriff auf IhreDatenbank.

Erstellen einer Tabelle

So können Sie eine Tabelle festlegen und erstellen

1. Führen Sie im Stammverzeichnis Ihrer App folgenden Befehl aus:


2. Gestalten Sie Ihre Tabelle, wenn Sie von der CLI dazu aufgefordert werden.

Die CLI fordert Sie auf, die Tabelle und andere Tabellenkonfigurationen wie Spalten bereitzustellen.

Welcome to NoSQL database wizardYou will be asked a series of questions to help determine how to best construct your NoSQL database table.

? Should the data of this table be open or restricted by user? Open? Table name Notes

You can now add columns to the table.

? What would you like to name this column NoteId? Choose the data type string? Would you like to add another column Yes? What would you like to name this column NoteTitle? Choose the data type string? Would you like to add another column Yes? What would you like to name this column NoteContent? Choose the data type string? Would you like to add another column No

Wählen Sie einen primären Schlüssel aus, der die einzelnen Elemente eindeutig identifiziert. WählenSie optional eine Spalte als Sortierschlüssel aus, wenn Sie diese Werte häufig in Verbindung mitdem primären Schlüssel zum Sortieren oder Durchsuchen Ihrer Daten verwenden. Um zusätzlicheSortierschlüssel hinzuzufügen, fügen Sie einen sekundären Index für jede Spalte hinzu, nach der Siesortieren möchten.

Before you create the database, you must specify how items in your table are uniquely organized. This is done by specifying a Primary key. The primary key uniquely identifies each item in the table, so that no two items can have the same key.This could be and individual column or a combination that has "primary key" and a "sort key".To learn more about primary key:http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey

? Select primary key NoteId? Select sort key (No Sort Key)

You can optionally add global secondary indexes for this table. These are useful when running queries defined by a different column than the primary key.

To learn more about indexes:

http://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.SecondaryIndexes

45

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.PrimaryKey

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.CoreComponents.html#HowItWorks.CoreComponents.SecondaryIndexes


? Add index NoTable Notes added

Erstellen einer CRUD API

AWS Mobile erstellt eine benutzerdefinierte API für Ihre App, mit der Sie CRUD-Aktionen (erstellen, lesen,aktualisieren und löschen) für die Datenbank ausführen können.

So erstellen Sie eine CRUD-API für Ihre Tabelle



2. Wählen Sie nach Aufforderung Create CRUD API for existing Dynamo table aus, klicken Sieauf den Tabellennamen aus den vorherigen Schritten und die Zugriffsberechtigungen für die Tabelle.Verwenden der Beispieltabelle aus dem vorherigen Abschnitt:

? Select from one of the choices below. Create a new API# Create CRUD API for an existing Amazon DynamoDB table

Die Anforderungsantwort sieht wie folgt aus:

Path to be used on API for get and remove an object should be like:/Notes/object/:NoteId

Path to be used on API for list objects on get method should be like:/Notes/:NoteId

JSON to be used as data on put request should be like:{ "NoteTitle": "INSERT VALUE HERE", "NoteContent": "INSERT VALUE HERE", "NoteId": "INSERT VALUE HERE"}To test the api from the command line (after awsmobile push) use this commandsawsmobile cloud-api invoke NotesCRUD <method> <path> [init]Api NotesCRUD saved

Kopieren Sie den Pfad Ihrer API und der JSON für Ihren App-Code.

Mit dieser Funktion wird eine API basierend auf Amazon API Gateway und AWS Lambda erstellt. Siekönnen optional Lambda-Funktionen verwenden, um CRUD-Operationen für Ihre Amazon DynamoDB-Tabelle ausführen.

3. Aktualisieren Sie Ihr Backend.

Führen Sie folgenden Befehl aus, um die konfigurierte API zu erstellen:

awsmobile push

Bis die Bereitstellung der API in der Cloud abgeschlossen ist, zeigt die CLI folgende Nachricht an:cloud-api update status: CREATE_IN_PROGRESS. Nachdem die Bereitstellung erfolgreichabgeschlossen wird, wird zur Bestätigung die folgende Nachricht angezeigt: cloud-api updatestatus: CREATE_COMPLETE.

46


Um die von der CLI erstellte API anzuzeigen, führen Sie den Befehl awmobile console aus undklicken Sie dann in der Mobile Hub-Konsole auf Cloud Logic.


Themen• Speichern eines Elements (erstellen oder aktualisieren) (p. 47)• Abrufen eines bestimmten Elements (p. 48)• Element löschen (p. 48)• Benutzeroberfläche zum Ausführen von CRUD-Aufrufen (p. 48)

So greifen Sie aus der App auf Datenbanktabellen zu

1. Importieren Sie in App.js Folgendes:

import Amplify, { API } from 'aws-amplify';import aws_exports from 'path_to_your_aws-exports';Amplify.configure(aws_exports);

2. Fügen Sie den folgenden state zu Ihrer Komponente hinzu.

state = { apiResponse: null, noteId: '' };

handleChangeNoteId = (event) => { this.setState({noteId: event});}

Speichern eines Elements (erstellen oder aktualisieren)

So speichern Sie ein Element

Rufen Sie in dem Teil der App, in dem Sie auf die Datenbank zugreifen (z. B. ein Ereignis-Handler in IhrerReact-Komponente) die Methode put auf. Verwenden Sie die JSON und den Stammpfad (/Notes) derAPI, die Sie zuvor in der CLI-Anforderungsantwort kopiert haben.

// Create a new Note according to the columns we defined earlier async saveNote() { let newNote = { body: { "NoteTitle": "My first note!", "NoteContent": "This is so cool!", "NoteId": this.state.noteId } } const path = "/Notes";

// Use the API module to save the note to the database try { const apiResponse = await API.put("NotesCRUD", path, newNote) console.log("response from saving note: " + apiResponse); this.setState({apiResponse}); } catch (e) { console.log(e);

47


} }

Führen Sie in der Befehlszeile den folgenden Befehl aus, um gespeicherte Elemente in der Datenbankanzuzeigen:

awsmobile cloud-api invoke NotesCRUD GET /Notes/object/${noteId}

Abrufen eines bestimmten Elements

So fragen Sie die Datenbank nach einem bestimmten Element ab

Rufen Sie die Methode get mit dem API-Pfad (zuvor kopiert) für das Element auf, das Sie abfragenmöchten.

// noteId is the primary key of the particular record you want to fetch async getNote() { const path = "/Notes/object/" + this.state.noteId; try { const apiResponse = await API.get("NotesCRUD", path); console.log("response from getting note: " + apiResponse); this.setState({apiResponse}); } catch (e) { console.log(e); } }

Element löschen

So löschen Sie einen Artikel

Fügen Sie diese Methode Ihrer Komponente hinzu. Verwenden Sie den (zuvor kopierten) API-Pfad.

// noteId is the NoteId of the particular record you want to delete async deleteNote() { const path = "/Notes/object/" + this.state.noteId; try { const apiResponse = await API.del("NotesCRUD", path); console.log("response from deleting note: " + apiResponse); this.setState({apiResponse}); } catch (e) { console.log(e); } }

Benutzeroberfläche zum Ausführen von CRUD-Aufrufen

Nachfolgend finden Sie ein Beispiel für das Erstellen einer Benutzeroberfläche zum Ausführen dieserOperationen.

<View style={styles.container}> <Text>Response: {this.state.apiResponse && JSON.stringify(this.state.apiResponse)}</Text> <Button title="Save Note" onPress={this.saveNote.bind(this)} /> <Button title="Get Note" onPress={this.getNote.bind(this)} /> <Button title="Delete Note" onPress={this.deleteNote.bind(this)} /> <TextInput style={styles.textInput} autoCapitalize='none' onChangeText={this.handleChangeNoteId}/>

48


</View>

const styles = StyleSheet.create({ container: { flex: 1, backgroundColor: '#fff', alignItems: 'center', justifyContent: 'center', }, textInput: { margin: 15, height: 30, width: 200, borderWidth: 1, color: 'green', fontSize: 20, backgroundColor: 'black' }});

Nächste Schritte

Weitere Informationen zur NoSQL Database (p. 57)-Funktion von AWS Mobile, die Amazon DynamoDBverwendet.



Hinzufügen von SpeicherImportant



Mit der Funktion User File Storage (p. 77) der AWS Mobile CLI können Apps Benutzerdateien in derCloud speichern.


So konfigurieren Sie den Cloud-Speicherort Ihrer App

Führen Sie im Stammverzeichnis Ihrer App folgenden Befehl aus:

awsmobile user-files enable

awsmobile push

49

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Introduction.html

https://github.com/aws/aws-amplify/tree/master/packages/aws-amplify-react-native





So fügen Sie der App User File Storage hinzu

In der Komponente, in der Sie Dateien übertragen möchten:

Importieren Sie das Storage-Modul aus aws-amplify und konfigurieren Sie es für die Kommunikation mitIhrem Backend.

import { Storage } from 'aws-amplify';

Nachdem das Speichermodul nun importiert wurde und für die Kommunikation mit dem Backend bereit ist,implementieren Sie gängige Dateiübertragungsaktionen mit dem folgenden Code.

Hochladen einer Datei

So laden Sie eine Datei in den Speicher hoch

Fügen Sie die folgenden Methoden zu der Komponente hinzu, in der Sie Datei-Uploads verarbeiten.

async uploadFile() { let file = 'My upload text'; let name = 'myFile.txt'; const access = { level: "public" }; // note the access path Storage.put(name, file, access);}

Eine bestimmte Datei abrufen

So laden Sie eine Datei aus dem Cloud-Speicher herunter

Fügen Sie den folgenden Code zu einer Komponente hinzu, in der Sie Dateien anzeigen.

async getFile() { let name = 'myFile.txt'; const access = { level: "public" }; let fileUrl = await Storage.get(name, access); // use fileUrl to get the file}

Alle Dateien auflisten

So listen Sie die für Ihre App in der Cloud gespeicherten Dateien auf

Fügen Sie den folgenden Code zu einer Komponente hinzu, in der Sie eine Sammlung von Dateienanzeigen.

async componentDidMount() { const path = this.props.path; const access = { level: "public" }; let files = await Storage.list(path, access); // use file list to get single files}

Verwenden Sie den folgenden Code, um Dateiattribute wie Größe oder letztes Änderungsdatum abzurufen.

file.Size; // file size

50


file.LastModified.toLocaleDateString(); // last modified datefile.LastModified.toLocaleTimeString(); // last modified time

Eine Datei löschen

Fügen Sie dem Element, in dem Sie Dateiübertragungen verarbeiten, den folgenden Status hinzu.

async deleteFile(key) { const access = { level: "public" }; Storage.remove(key, access);}

Nächste Schritte

Erfahren Sie mehr über die Analysen in AWS Mobile, die Teil der Funktion User File Storage (p. 77)sind. Diese Funktion verwendet Amazon Simple Storage Service (S3).



Zugriff auf Ihre APIsImportant




Mit der AWS Mobile-Funktion Cloud Logic (p. 54) können Sie APIs in der Cloud aufrufen. API-Aufrufewerden von Ihren serverlosen Lambda-Funktionen verarbeitet.

So aktivieren Sie Cloud-APIs in Ihrer App

awsmobile cloud-api enable

awsmobile push

Wenn Sie Cloud Logic in Ihrer App aktivieren, wird die Beispiel-API sampleCloudApi zu Ihrem Projekthinzugefügt, die Sie zu Testzwecken verwenden können.

Führen Sie im Stammverzeichnis Ihrer App awsmobile console aus und klicken Sie in Ihrem MobileHub-Projekt auf die Funktion Cloud Logic, um die Beispiel-Handler-Funktion für die API anzuzeigen.

51

https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html





Schnelltesten Ihrer API über die CLI

Mit der sampleCloudApi und deren Handler-Funktionen können Sie End-to-End-API-Aufrufe tätigen.

So testen Sie das Aufrufen Ihrer unsignierten APIs in der Entwicklungsumgebung

awsmobile cloud-api invoke <apiname> <method> <path> [init]

Für die sampleCloudApi können Sie die folgenden Beispiele verwenden, um die post-Methode zutesten.

awsmobile cloud-api invoke sampleCloudApi post /items '{"body": {"testKey":"testValue"}}'

Dieser Aufruf gibt eine Antwort ähnlich wie die folgende zurück:

{ success: 'post call succeed!',url: '/items',body: { testKey: 'testValue' } }

So testen Sie die :get-Methode

awsmobile cloud-api invoke sampleCloudApi get /items

Hierdurch wird eine Antwort wie folgt zurückgegeben:

{ success: 'get call succeed!', url: '/items' }


Sobald Sie eigene Cloud Logic (p. 54)-APIs und Lambda-Funktionen erstellt haben, können Sie sie ausIhrer App aufrufen.

52


So rufen Sie APIs aus Ihrer App auf

Fügen Sie in App.js (oder anderem Code, der zur Startzeit ausgeführt wird), den folgenden Import hinzu.

import Amplify, { API } from 'aws-amplify';import aws_exports from './aws-exports';Amplify.configure(aws_exports);

Fügen Sie dann Folgendes zu der Komponente hinzu, die Ihre API aufruft.

state = { apiResponse: null };

async getSample() { const path = "/items"; // you can specify the path const apiResponse = await API.get("sampleCloudApi" , path); //replace the API name console.log('response:' + apiResponse); this.setState({ apiResponse });}

Um Ihre API über ein Benutzeroberflächenelement aufzurufen, fügen Sie einen API-Aufruf innerhalb derrender()-Methode der Komponente hinzu.

<View> <Button title="Send Request" onPress={this.getSample.bind(this)} /> <Text>Response: {this.state.apiResponse && JSON.stringify(this.state.apiResponse)}</Text></View>

Speichern Sie zum Testen die Änderungen und führen Sie npm run android oder npm run ios` aus,um die App zu starten. Probieren Sie nun das Benutzeroberflächenelement aus, das zum Aufrufen der APIverwendet wird.

Nächste Schritte

Weitere Informationen zur AWS Mobile Cloud Logic (p. 54)-Funktion, die Amazon API Gateway undAWS Lambda verwendet.

Wenn Sie eine Anleitung zum Erstellen einer API und deren Handler benötigen, führen Sie awsmobileconsole aus, um Ihre App in der Mobile Hub-Konsole zu öffnen, und klicken Sie auf Cloud Logic.



AWS Mobile Hub-FunktionenImportant


Die folgenden Seiten enthalten Referenzmaterial für die AWS Mobile-CLI für Web (JavaScript).

• AWS Mobile CLI-Referenz (p. 25)

53

https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html

https://docs.aws.amazon.com/lambda/latest/dg/welcome.html




AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchMobile Hub-Funktionen

• AWS Mobile CLI-Anmeldeinformationen (p. 35)

AWS Mobile Hub-Funktionen

Suchen Sie die AWS SDKs für iOS und Android? Diese SDKs und die zugehörigen Dokumente sind nunTeil von AWS Amplify.

Der Inhalt auf dieser Seite gilt nur für Apps, die mithilfe von AWS Mobile Hub oder der awsmobileCLI konfiguriert wurden. Für vorhandene Apps, die AWS Mobile SDK vor Version 2.8.0 verwenden,empfehlen wir dringend, dass Sie Ihre App auf AWS Amplify und das neueste SDK migrieren.

AWS Mobile Hub ist ein Service, mit dem auch unerfahrene Benutzer mithilfe einer Reihe vonleistungsstarken AWS-Services die Backend-Funktionen für mobile Apps einfach bereitstellen undkonfigurieren können.

Sie erstellen ein kostenloses Projekt und wählen anschließend die Funktionen für mobile Apps aus undkonfigurieren sie mithilfe einer"Point-and-Click"-Konsole. Mobile Hub kümmert sich um die Komplexität imHintergrund und liefert Ihnen Schritt-für-Schritt-Integrationsanweisungen.

Themen• Cloud Logic (p. 54)• NoSQL Database (p. 57)• Messaging und Analysen (p. 63)• Hosting und Streaming (p. 65)• Conversational Bots (p. 70)• Benutzeranmeldung (p. 72)• User File Storage (p. 77)

Cloud Logic



Wählen Sie die AWS Mobile Hub Cloud Logic Servicefunktion für mobile Backends um:

• Hinzufügen von Geschäftslogikfunktionen in der Cloud ohne Kosten für die Einrichtung oder Wartung desServers

• Erweitern Ihrer App auf andere Services innerhalb und außerhalb von AWS

Erstellen Sie ein kostenloses Mobile Hub-Projekt und fügen Sie die Cloud Logic-Funktion hinzu.

FunktionsdetailsDie folgende Abbildung zeigt Cloud Logic mit der Kombination von Amazon API Gateway und AWSLambda, um eine serverlose Geschäftslogik samt Erweiterung auf andere Services zu implementieren.

54

https://amzn.to/am-amplify-docs




https://console.aws.amazon.com/mobilehub/home#/


Mit der Cloud Logic-Funktion können Sie Backend-Services mit AWS Lambda-Funktionen erstellen, dieSie von Ihrer mobilen App aus aufrufen können. Mit Cloud Logic können Sie Code in der Cloud ausführen,um Geschäftslogik für Ihre Apps zu verarbeiten und um denselben Code für iOS- und Android-Appsgemeinsam zu nutzen. Die Cloud Logic-Funktion wird von AWS Lambda-Funktionen unterstützt, mitdenen Sie Code schreiben können, ohne sich um die Verwaltung von Frameworks und die Skalierung derBackend-Infrastruktur kümmern zu müssen. Sie können Ihre Funktionen in JavaScript, Java oder Pythonschreiben.

Die Lambda-Funktionen, die Sie erstellen, werden Ihrer App als REST API vom Amazon API Gatewayzur Verfügung gestellt, das auch einen einzelnen sicheren Endpunkt mit flexiblen Überwachungs- undDrosselungsfunktionen für den Datenverkehr bietet.

Cloud Logic auf einen Blick

Konfigurierte AWS-Services und -Ressourcen • Amazon API Gateway (siehe Amazon APIGateway-Entwicklerhandbuch)

Konzepte | Konsole | Preise• AWS Lambda (siehe AWS Lambda-

Entwicklerhandbuch)

Konzepte | Konsole | Preise• Amazon Virtual Private Cloud (siehe Amazon

VPC-Benutzerhandbuch)

Konzepte | Konsole | Preise• AWS CloudFormation (siehe AWS

CloudFormation-Benutzerhandbuch)

Konzepte | Konsole | Preise

Mobile Hub-fähige Funktionen verwenden AmazonCognito für die Authentifizierung und IAM für dieAutorisierung. Weitere Informationen finden Sieunter User Sign-in (Benutzeranmeldung) (p. 72).Weitere Informationen finden Sie unter Anzeigen

55

https://aws.amazon.com/lambda/getting-started/

https://docs.aws.amazon.com/apigateway/latest/developerguide/

https://docs.aws.amazon.com/apigateway/latest/developerguide/

https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-basic-concept.html

https://console.aws.amazon.com/apigateway/

https://aws.amazon.com/api-gateway/pricing/

https://docs.aws.amazon.com/lambda/latest/dg/



https://console.aws.amazon.com/lambda/

https://aws.amazon.com/lambda/pricing/

https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/

https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/

https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Introduction.html#Overview

https://console.aws.amazon.com/vpc/

https://docs.aws.amazon.com/AmazonVPC/latest/UserGuide/VPC_Introduction.html#Paying

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-whatis-concepts.html

https://console.aws.amazon.com/cloudformation/home

https://aws.amazon.com/cloudformation/pricing/


von für diese Funktion bereitgestellten AWS-Ressourcen (p. 56).

Konfigurationsoptionen Diese Funktion aktiviert die folgenden Fähigkeitendes mobilen Backends:

• Bietet eine Standardfunktion Hello WorldLambda-Funktion an, die den vom App-Benutzereingegebenen Parameterwert akzeptiert und aneine App zurückgibt.

• Ermöglicht es Ihnen, eine vorhandene Funktionaus der Liste auszuwählen oder neue Funktionenüber die AWS Lambda-Konsole zu erstellen.

Schnellstart-App-Demos Diese Funktion fügt einer von Mobile Hubgenerierten Schnellstart-App die folgendeFunktionalität hinzu:

• Der Benutzer kann eine AWS Lambda-Funktionmit Namen angeben, Parameter übergeben undeine Funktion aufrufen, und den von der Funktionzurückgelieferten Wert sehen.

Anzeigen von für diese Funktion bereitgestellten AWS-Ressourcen

Die folgende Abbildung zeigt den Mobile Hub-Bereich Resources (Ressourcen) mit Elementen, dienormalerweise für die Cloud Logic-Funktion für die Benutzeranmeldung bereitgestellt werden.

56


Schnellstart-App-DetailsIhre Schnellstart-App enthält Code zur Verwendung der AWS Lambda-APIs, um alle Funktionenaufzurufen, die Sie in Ihrem Projekt ausgewählt haben. Durch Hinzufügen von Cloud Logic zu IhrerSchnellstart-App erhalten Sie eine Hello World Lambda-Funktion. Sie können auch eine bestehendeLambda-Funktion aus Ihrem AWS-Konto auswählen oder eine neue erstellen. Wenn Sie die SchaltflächeEdit wählen, gelangen Sie in den Funktionseditor der AWS Lambda-Konsole. Von der Lambda-Konsoleaus können Sie den Code direkt bearbeiten oder ein Paket mit Quellcode und Bibliotheken als .zip-Dateihochladen.

Im Demobildschirm der Cloud Logic Schnellstart-App können Sie den Namen und die Eingabeparameterder Lambda-Funktion eingeben, die Sie aufrufen möchten. Die Schnellstart-App ruft dann Ihre Lambda-Funktion auf und zeigt die Ergebnisse an, die sie zurückgibt.

NoSQL Database



Verwenden Sie die mobile Backend-Funktion Mobile Hub NoSQL Database für die folgenden Zwecke:

• Einfache zu entwickelnde Datenbankfunktionen mit skalierbarer Leistung und Kosten hinzufügen

Erstellen eines kostenlosen Mobile-Hub-Projekts und Hinzufügen der NoSQL DB-Funktion innerhalb vonwenigen Minuten.

FunktionsdetailsDie folgende Abbildung zeigt die typische Verbindung zwischen einer mobilen App und AmazonDynamoDB mit dem NoSQL-Muster.

Die NoSQL Database-Funktion verwendet Amazon DynamoDB, damit Sie Datenbanktabellen erstellenkönnen, die Daten zur Verwendung durch Ihre Apps speichern und abrufen können.

NoSQL-Datenbanken sind aufgrund ihrer einfachen Entwicklung, skalierbaren Leistung, hohenVerfügbarkeit und Ausfallsicherheit als Methode der Wahl für viele mobile Backend-Lösungen anerkannt.Weitere Informationen finden Sie unter Von SQL bis NoSQL im Amazon DynamoDB-Entwicklerhandbuch.

57





https://aws.amazon.com/dynamodb/

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SQLtoNoSQL.html


NoSQL Database auf einen Blick

Konfigurierte AWS-Services und -Ressourcen • Amazon DynamoDB-Tabellen (siehe Arbeiten mitTabellen in DynamoDB)


Mobile Hub-fähige Funktionen verwenden AmazonCognito für die Authentifizierung und IAM für dieAutorisierung. Weitere Informationen finden Sieunter User Sign-in (Benutzeranmeldung) (p. 72).Weitere Informationen finden Sie unter Anzeigenvon für diese Funktion bereitgestellten AWS-Ressourcen (p. 62).

Konfigurationsoptionen Diese Funktion aktiviert die folgenden Fähigkeitendes mobilen Backends für Apps:

Konfigurieren Ihrer Tabellen (p. 59) –Verwendung eines benutzerdefiniertenSchemas basierend auf einem bereitgestelltenBeispielschema oder mithilfe eines Assistenten,der Sie beim Erstellen einer Tabelle durch dieAuswahlen führt.

Datenberechtigungen (p. 60) – Der Zugriff aufdie Daten Ihrer App kann sein:

• Public (Öffentlich) (ermöglicht jedem Benutzereiner mobilen App, beliebige Elemente in derTabelle zu lesen oder zu schreiben).

• Protected (Geschützt) (ermöglicht es jedemBenutzer einer mobilen App, ein beliebigesElement in der Tabelle zu lesen, aber nurder Besitzer eines Elements kann diesesaktualisieren oder löschen).

• Private (Privat) (ermöglicht nur dem Eigentümereines Eintrags, eine Tabelle zu lesen und zuschreiben). Weitere Informationen finden Sieim Thema Konfigurieren der NoSQL Datase-Funktion (p. 59).

Weitere Informationen finden Sie im ThemaKonfigurieren der NoSQL Database-Funktion (p. 59).

Schnellstart-App-Demos Diese Funktion fügt einer von Mobile Hubgenerierten Schnellstart-App Folgendes hinzu:

• Einfügen und Entfernen von Beispieldaten,basierend auf dem Schema, das Sie in derKonsole angeben.

• Führen Sie NoSQL-Operationen für Tabellenaus und sehen Sie sich die Ergebnissean, unter anderem für Get, Scan und alle

58

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/

https://console.aws.amazon.com/dynamodb/home

https://aws.amazon.com/dynamodb/pricing/


Beispielabfragen, die von der Konsole angezeigtwerden, wenn Sie Designauswahlen vornehmen.

Konfigurieren der NoSQL Database-FunktionDieser Abschnitt beschreibt Schritte und Optionen zur Konfiguration von NoSQL Database-Funktionen inMobile Hub.

So fügen Sie die NoSQL Database-Funktion zu Ihrem |AMH|-Projekt hinzu

1. Wählen Sie Enable NoSQL (NoSQL aktivieren).2. Wählen Sie Add a new table (Eine neue Tabelle hinzufügen).3. Wählen Sie das anfängliche Schema für die Tabelle aus. Sie können ein mitgeliefertes Beispielschema

verwenden oder über den Assistenten ein Schema generieren.

Beispiele für Tabellenschemas

AWS Mobile Hub stellt eine Reihe von Beispieltabellenschemas für typische mobile Apps zur Verfügung.Wenn Sie eine Tabelle mit einer der Schema-Beispielschablonen anlegen, besitzt die Tabelle anfänglicheinen Satz von Attributen, die für jedes Beispiel spezifisch sind. Sie können eine dieser Vorlagen alsanfängliches Schema für Ihre Tabelle auswählen:

• News (Nachrichten), das Autor, Titel, Artikelinhalt, Schlüsselwörter und andere Attribute derNachrichtenartikel speichert.

• Locations (Orte), das Namen, Breiten- und Längengrade von geografischen Orten speichert.• Notes (Notizen), das private Notizen für jeden Benutzer speichert.• Ratings (Bewertungen), das Benutzerbewertungen für einen Katalog von Elementen speichert.• Graffiti Wall (Graffiti-Wand), das gemeinsam genutzte Zeichnungselemente speichert.

So fügen Sie eine Tabelle mit einer der Schema-Beispielvorlagen in Ihrem |AMH|-Projekt hinzu

1. Wählen Sie die Beispielvorlage aus, die für das anfängliche Schema der Tabelle verwendet werden soll.2. Geben Sie einen neuen Namen in Table name (Tabellenname) ein, um die Tabelle gegebenenfalls

umzubenennen. Jede Vorlage gibt der Tabelle einen Standardnamen, der mit dem Namen der Vorlageübereinstimmt.

3. Wählen Sie Public (Öffentlich), Protected (Geschützt) oder Private (Privat), um den Benutzern dermobilen App Berechtigungen für die Tabelle zu erteilen. Weitere Informationen finden Sie unterDatenberechtigungen (p. 60).

4. (Optional) Unter What attributes do you want on this table? (Welche Attribute möchten Sie für dieseTabelle?) können Sie Tabellenattribute hinzufügen, umbenennen oder löschen.

5. (Optional) Wählen Sie Add index (Index hinzufügen), um name (Name), partition key(Partitionsschlüssel) und (optional) sort key (Sortierschlüssel) als sekundären Index für Ihre Tabellehinzuzufügen.

6. Wählen Sie Create table aus.

Konfigurieren Ihrer TabellenDieser Abschnitt beschreibt Optionen für die Konfiguration von DynamoDB NoSQL-Tabellen für Ihre App.

Themen• Terminologie für NoSQL-Tabellen (p. 60)• Datenberechtigungen (p. 60)

59


Terminologie für NoSQL-Tabellen

Ebenso wie bei anderen Datenbankmanagementsystemen werden auch die Daten von DynamoDB inTabellen gespeichert. Eine Tabelle ist eine Sammlung von Daten mit den folgenden Elementen.

Elemente

• Jede Tabelle enthält mehrere Elemente. Ein Element ist eine Gruppe von Attributen, die unter allenanderen Elementen eindeutig identifizierbar ist. Elemente sind ähnlich Zeilen, Datensätzen oder Tupelnin relationalen Datenbanksystemen.

Attribute

• Attribute sind die Spalten in einer DynamoDB-Tabelle. Die Zeilen der Tabelle sind die einzelnenDatensätze, die Sie hinzufügen, aktualisieren, lesen oder löschen, wie für Ihre App erforderlich.

Das Tabellenschema stellt eine Reihe von anfänglichen Attributen zur Verfügung, die auf denBedürfnissen jedes Beispiels basieren. Mit Remove (Entfernen) können Sie diese Attribute beliebiglöschen. Wenn Sie das Partitionsschlüsselattribut entfernen, müssen Sie ein anderes Attribut alsPartitionsschlüssel für den Primärindex der Tabelle angeben.

Mit Add attribute (Attribut hinzufügen) fügen Sie der Tabelle ein leeres Attribut hinzu. Geben Sie demAttribut einen Namen, wählen Sie den Typ der zu speichernden Daten und wählen Sie, ob das neueAttribut der Partitionsschlüssel oder der Sortierschlüssel ist.

Indizes

• Jede Tabelle hat einen eingebauten Primärindex, der einen Partitionsschlüssel hat und auch einenSortierschlüssel haben kann. Dieser Index erlaubt spezifische Abfragetypen. Welche Abfrageartendie Tabelle unterstützt, sehen Sie durch Expandieren des Abschnitts Queries this table can perform(Über diese Tabelle mögliche Abfragen). Um Abfragen mit anderen Attributen zu ermöglichen, legenSie zusätzliche Sekundärindizes an. Sekundärindizes ermöglichen den Zugriff auf die Daten mit einemanderen Partitionsschlüssel und optionalem Sortierschlüssel als denjenigen des Primärindex.

Datenberechtigungen

Eine bewährte Methode für Datensicherheit ist es, nur den minimalen Zugriff auf Ihre Tabellen zuermöglichen, die das Design Ihrer App unterstützen. Mobile Hub bietet zwei Methoden zum SchutzIhrer Daten: Benutzerauthentifizierung mit Hilfe der Funktion zur Benutzeranmeldung (p. 72) undBenutzerberechtigungen für NoSQL-Datenbank-Datentabellen.

Hinweis: Wenn die NoSQL-Datenbank aktiviert ist, kommuniziert Ihre App direkt mit dem DynamoDB-Service. Wenn Sie die Funktion der Benutzeranmeldung (p. 72) nicht als Required (Erforderlich)konfigurieren, haben nicht authentifizierte Benutzer Lese- und/oder Schreibzugriff auf die Daten, falls sienicht durch Benutzerberechtigungen für Tabellen daran gehindert werden.

Erteilen von Berechtigungen nur für authentifizierte Benutzer

Es sei denn, Benutzer, die nicht angemeldet sind, müssen Daten in einer Tabelle in Ihrer Anwendunglesen oder schreiben, schränken Sie den Zugriff ein, indem sie Benutzer dazu auffordern, sich anzumelden(authentifizieren), bevor sie App-Funktionen verwenden dürfen, die Datenbankoperationen ausführen.Die AWS Mobile Hub-Funktion der Benutzeranmeldung (p. 72) bietet eine Reihe von Methoden zurAuthentifizierung von Benutzern, wie beispielsweise: Verbund mit einem Anmeldeanbieter wie Facebook,Google, Active Directory oder Ihrem bestehenden benutzerdefinierten Service. Mit wenigen Klicks könnenSie auch Ihren eigenen, von AWS-Services unterstützten Anmeldeanbieter erstellen.

Um Ihrer App eine Benutzeranmeldung hinzuzufügen, verwenden Sie die Schaltfläche Configure morefeatures (Mehr Funktionen konfigurieren) auf einer Funktionskonfigurationsseite oder das Symbol

60


Configure (Konfigurieren) links in der Konsole. Anschließend wählen und aktivieren Sie User Sign-in(Benutzeranmeldung).

Berechtigungen für Tabellendatenelemente für einzelne Benutzer

Wenn Sie eine neue Tabelle in NoSQL Database erstellen, wählen Sie die Optionen Public (Öffentlich),Private (Privat) oder Protected (Geschützt), um festzulegen, welche App-Benutzer die Daten in der Tabellelesen oder schreiben können. Mobile Hub fügt der Tabelle eine feingranulare Zugriffskontrollrichtlinie hinzu,die die einem Benutzer zur Verfügung stehenden Operationen einschränken kann, je nachdem, ob er derErsteller der Daten ist, auf die zugegriffen wird.

Öffentlich

• Public-Berechtigungen erlauben es allen Benutzern, alle Elemente (Datenzeilen) in der Tabelle zu lesenoder zu aktualisieren.

Geschützt

• Protected-Berechtigungen erlauben es allen Benutzern, alle Elemente in der Tabelle zu lesen, aber nurder Eigentümer eines Elements kann dieses Element aktualisieren oder löschen.

Privat

• Private-Berechtigungen erlauben es nur dem Besitzer eines Elements, es zu lesen oder zu schreiben.

Note

Benutzer sind Eigentümer eines Datenelements, wenn ihre Amazon Cognito Identitäts-ID mit demWert des Primärschlüssels für das Element übereinstimmt.Wenn Sie die Berechtigungen Protected (Geschützt) oder Private (Privat) für eine Tabelleauswählen, muss der Partitionsschlüssel der Tabelle userId sein und sein Typ muss stringsein. Sekundärindizes für geschützte oder private Tabellen folgen dem gleichen Muster wiePrimärindizes.Wenn ein Benutzer ein Element in einer geschützten oder privaten Tabelle erstellt, füllt AWS denWert des Primärschlüssels des Elements mit der Amazon Cognito Identitäts-ID dieses Benutzers.Die Durchsetzung erfolgt, wenn eine Datenoperation für ein geschütztes oder privates Objektversucht wird. IAM überprüft, ob die userId des Eintrags mit der Amazon Cognito-Identitäts-IDdes aktuellen Benutzers übereinstimmt, und erlaubt oder verhindert die Operation basierend aufder Richtlinie, die der Tabelle angehängt ist.Wenn Sie Public (Öffentlich)-Berechtigungen für eine Tabelle wählen, wird das Eigentumnicht durchgesetzt. Es gibt keine Einschränkungen hinsichtlich Name oder Datentyp desPrimärschlüssels und des Sekundärindex-Primärschlüssels einer öffentlichen Tabelle.

Berechtigungen für eingeschränkte Elemente für mehrere Autoren verwalten

Nachdem Mobile Hub Zugriffsbeschränkungen für Ihre Tabellen mit Protected (Geschützt)- oder Private(Privat)-Berechtigungen festgelegt hat, stellt IAM sicher, dass nur der mobile App-Benutzer, dessen Aktionein Element in der Tabelle erstellt, in die Attributwerte dieses Elements schreiben kann. Um Ihr Schemafür den Fall zu entwerfen, dass mehrere Benutzer Daten in ein vorhandenes Element schreiben müssen,ist eine Strategie, Ihr Schema so zu strukturieren, dass Benutzer in verschiedene Tabellen schreiben. Indiesem Design fragt die App beide Tabellen ab, um Daten zu verknüpfen.

Beispielsweise könnten Kunden Aufträge in einer orders-Tabelle erstellen, und Paketboten könntenInformationen zur Nachverfolgung einer Lieferung in eine deliveries-Tabelle schreiben, und beideTabellen könnten Sekundärindizes besitzen, die eine schnelle Suche basierend auf orderId odercustomerId erlaubt.

61


Daten abrufen

Operationen, mit denen Sie Daten aus Ihrer NoSQL-Datenbank abrufen können, sind unter anderem:

• Get, das ein einzelnes Element aus der Tabelle abhängig von der Übereinstimmung mit demPrimärschlüssel abruft.

• Query, das Elemente ausschließlich unter Verwendung von Primärschlüssel-Attributwerten in einerTabelle oder einem Sekundärindex findet.

• Ein Scan, das jedes Element in einer Tabelle oder einem Sekundärindex liest. Standardmäßig gibt einScan-Vorgang für jedes Element in der Tabelle oder im Index alle Datenattribute zurück. Sie könnenScan verwenden, um nur einige der Attribute zurückzugeben, und nicht alle.

• Query with Filter`s, which performs a :code:`Query, das einen durchführt, aberErgebnisse zurückgibt, die basierend auf einem von Ihnen erstellten Filterausdruck gefiltert werden.

• Scan with Filters, das einen Scan durchführt, aber Ergebnisse zurückgibt, die basierend auf einemvon Ihnen erstellten Filterausdruck gefiltert werden.

Weitere Informationen finden Sie unter Abfrage- und Scanoperationen in DynamoDB.


Die folgende Abbildung zeigt den Mobile Hub-Bereich Resources (Ressourcen) mit AWS-Elementen, dienormalerweise für die NoSQL Database-Funktion bereitgestellt werden:

Schnellstart-App-Details

In der Mobile Hub Schnellstart-App zeigt die NoSQL Datenbank-Demo eine Liste aller Tabellen, diewährend der Konfiguration des Programms erstellt wurden. Die Auswahl einer Tabelle zeigt eine Liste

62

https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html


aller Abfragen, die für diese Tabelle verfügbar sind, basierend auf den Auswahlen von Primärindizes,Sekundärindizes und Sortierschlüsseln. Tabellen, die Sie mit Hilfe der Beispielvorlagen erstellen,ermöglichen es einem App-Benutzer, Beispieldaten innerhalb der App einzufügen und zu entfernen.

Messaging und Analysen



Wählen Sie die AWS Mobile Hub-Funktion für Messaging und Analysen aus, um Folgendes durchzuführen:

• Erfassen von Daten, um bessere Einblicke in das Verhalten der Benutzer Ihrer App zu erhalten• Nutzen dieser Informationen, um Kampagnen für die Interaktion mit Ihren Benutzern über Push-

Benachrichtigungen, E-Mail oder SMS hinzuzufügen

Erstellen Sie ein kostenloses Mobile Hub-Projekt und fügen Sie die Funktion für Messaging und Analysenhinzu.

Funktionsdetails

Die Funktion für Messaging und Analysen von AWS Mobile Hub (die frühere Funktion "User Engagement")hilft Ihnen zu verstehen, wie Benutzer Ihre App verwenden. Sie gibt Ihnen die Möglichkeit der Interaktionmit ihnen mithilfe von Push-Benachrichtigungen, E-Mail oder SMS. Sie können Ihre Analysen mitIhrem Messaging verknüpfen, damit das Verhalten der Benutzer die Grundlage ist für das, was Siekommunizieren.

Die folgende Abbildung zeigt die Funktion für Messaging und Analysen unter Verwendung von AmazonPinpoint zur Erfassung von Nutzungsdaten von einer mobilen App. Amazon Pinpoint sendet dannMessaging-Nachrichten an ausgewählte App-Benutzer, basierend auf der für die App entwickeltenKampagnenlogik.

63





https://docs.aws.amazon.com/pinpoint/latest/userguide/welcome.html



Sie können die Messaging- und Analysefunktionen separat konfigurieren oder in Kombination verwenden,um Kampagnen durchzuführen und so mit Ihren Benutzern basierend auf deren App-Nutzung zuinteragieren. Sie können konfigurieren, welche Benutzer die Nachrichten zu einer Kampagne erhalten,und die Bedingungen und Planungslogik für das Versenden von Nachrichten festlegen. Sie könnenBenachrichtigungen konfigurieren, um Text zu kommunizieren oder eine programmgesteuerte Aktionauszulösen, wie etwa das Öffnen einer Anwendung oder das Übergeben eines benutzerdefinierten JSON-Objekts an Ihren Client.

Wenn Sie Analytics (Analysen) auswählen, führt Amazon Pinpoint die Erfassung, Visualisierung undAnalyse von App-Nutzungs- und Kampagnendaten durch:

• Standardmäßig erfasst Amazon Pinpoint Sitzungsdaten zur App-Nutzung.• Wenn Sie eine Kampagne konfigurieren, sind Metriken über Ihre Kampagne enthalten.• Wenn Sie Ihrer App benutzerdefinierte Analysen hinzufügen, können Sie Amazon Pinpoint

so konfigurieren, dass diese Metriken visualisiert werden, und die Daten als Faktor in IhremKampagnenverhalten verwenden. Weitere Informationen über das Integrieren benutzerdefinierterAnalysen finden Sie unter Integrieren von Amazon Pinpoint in Ihre App im Amazon Pinpoint-Entwicklerhandbuch.

• Amazon Pinpoint gibt Ihnen die Möglichkeit, Trichter-Analysen zu erstellen, die bildlich darstellen, wieviele Benutzer die einzelnen Abfolgen von Schritten in Ihrer App wie von Ihnen vorgesehen ausführen.

• Um komplexere Analyseaufgaben durchzuführen, wie etwa das Zusammenführen von Daten aus mehrals einer App oder das Erstellen flexibler Abfragen, können Sie Amazon Pinpoint so konfigurieren, dassIhre Daten zu Kinesis gestreamt werden. Weitere Informationen über die gemeinsame Verwendung vonAmazon Pinpoint und Kinesis finden Sie unter Streamen von Amazon Pinpoint-Ereignissen an AmazonKinesis.

Wenn Sie Messaging auswählen, können Sie Ihr Projekt so konfigurieren, dass Amazon PinpointFolgendes senden kann:

• Push-Benachrichtigungen an Ihre Android-Benutzer über Firebase/Google Cloud Messaging oder aniOS-Benutzer über APNs

• E-Mails an Ihre App-Benutzer mithilfe der Sender-ID und Domäne Ihrer Wahl• SMS-Nachrichten

Sobald Sie die Messaging- und Analyse-Optionen in Ihrem Mobile Hub-Projekt aktiviert haben, verwendenSie die Amazon Pinpoint-Konsole, um bildliche Darstellungen Ihrer Analysen anzuzeigen oder IhreBenutzersegmente und Kampagnen zu konfigurieren. Sie können außerdem Benutzersegmentdaten inAmazon Pinpoint importieren, um Kampagnen für jede Gruppe von Benutzern zu verwenden.

Messaging und Analysen auf einen Blick

Konfigurierte AWS-Services und -Ressourcen • Amazon Pinpoint (siehe Amazon Pinpoint-Entwicklerhandbuch)

Konzepte | Konsole

Mobile Hub-fähige Funktionen verwenden AmazonCognito für die Authentifizierung und IAM für dieAutorisierung. Weitere Informationen finden Sieunter User Sign-in (Benutzeranmeldung) (p. 72).


64

https://docs.aws.amazon.com/pinpoint/latest/developerguide/mobile-sdk.html

https://docs.aws.amazon.com/pinpoint/latest/userguide/analytics-funnels.html

https://docs.aws.amazon.com/pinpoint/latest/userguide/analytics-streaming-kinesis.html

https://docs.aws.amazon.com/pinpoint/latest/userguide/analytics-streaming-kinesis.html

https://console.aws.amazon.com/pinpoint/home




https://console.aws.amazon.com/pinpoint/home


• Erfassen und Visualisieren von Analysen desVerhaltens der Benutzer Ihrer App• Integrieren von Amazon Pinpoint-

Benutzereinbindungskampagnen in Ihremobile App

• Kommunizieren mit App-Benutzern mithilfe vonPush-Benachrichtigungen über APNs, GCMund FCM• über Firebase oder Google Cloud

Messaging (FCM/GCM) (siehe Einrichtenvon Android-Push-Benachrichtigungen)

• über den Apple Push Notification-Service(APNs) (siehe Einrichten von iOS-Push-Benachrichtigungen)

Weitere Informationen finden Sieunter Konfigurieren der Push-Benachrichtigungsfunktion.

• Kommunizieren mit App-Benutzern per E-Mail• Kommunizieren mit App-Benutzern per SMS

Schnellstart-App-Demos Diese Funktion fügt einer von Mobile Hubgenerierten Schnellstart-App die Funktion UserEngagement hinzu:

• Zeigen, dass der Erhalt vonKampagnenbenachrichtigungen für den App-Benutzer aktiviert wurde. Der App-Benutzer kannEreignisse auslösen, die Sitzungs-, Kampagnen-oder Kaufdaten oder benutzerdefinierte Datenerzeugen. Analysen für diese Ereignisse sindin der Amazon Pinpoint-Konsole fast in Echtzeitverfügbar.

• Zeigen, dass dem App-Benutzer eine Ansichteiner Amazon Pinpoint-Datenvisualisierung aufseinem Mobiltelefon bereitgestellt wurde.

Hosting und StreamingWählen Sie Hosting und Streaming von AWS Mobile Hub für folgende Vorgänge:

• Hosten von Inhalt für Ihre mobile Web-App, systemeigene mobile App oder Hybrid-App• Verteilen von Inhalt über ein weltweites Content Delivery Network (CDN)• Streamen Ihrer Medien

Erstellen Sie ein kostenloses Mobile Hub-Projekt mit Hosting und Streaming. Erhalten Sie einebenutzerdefinierte Beispiel-App und ein SDK.

Funktionsdetails

Die Funktion für Hosting und Streaming stellt Inhalt über ein weltweites Netzwerk von Endpunkten mithilfevon Amazon Simple Storage Service (Amazon S3) und Amazon CloudFront bereit.

65

https://docs.aws.amazon.com/pinpoint/latest/developerguide/mobile-push-android.html

https://docs.aws.amazon.com/pinpoint/latest/developerguide/mobile-push-android.html

https://docs.aws.amazon.com/pinpoint/latest/developerguide/apns-setup.html

https://docs.aws.amazon.com/pinpoint/latest/developerguide/apns-setup.html

https://alpha-docs-aws.amazon.com/pinpoint/latest/developerguide/mobile-push.html

https://alpha-docs-aws.amazon.com/pinpoint/latest/developerguide/mobile-push.html



https://aws.amazon.com/s3/



Die folgende Abbildung zeigt, wie Website-Komponenten und Streaming-Medien an eine mobile Web-Appoder einen Browser verteilt werden. Es wird dargestellt, wie die Web-App AWS-Anmeldeinformationenanfordert und über AWS SDK for JavaScript auf AWS-Services zugreift.

Die folgende Abbildung zeigt eine systemeigene oder hybride mobile App, die AWS-Anmeldeinformationenanfordert, um von einem CDN-Edge-Standort aus auf Inhalt zuzugreifen.

Die Funktion für Hosting und Streaming gibt Ihnen die Möglichkeit, Website- und App-Komponenten in derCloud zu hosten, wie etwa HTML-, JavaScript-, Abbild- oder Mediendateien. Mobile Hub erstellt mithilfeeines Amazon S3-Buckets einen Inhaltsquellen-Speicherort (Ursprung). Der Bucket wird über das Internetdurch die Amazon S3-Möglichkeit, Webinhalt statisch ohne Webserver zu hosten, zugänglich gemacht.

Benutzern in allen Regionen wird der Zugriff auf Ihren Inhalt mit niedriger Latenz bereitgestellt, indem IhrQuellinhalt in einem weltweiten Netzwerk von Edge-Standorten zwischengespeichert wird. Dieses ContentDistribution Network (CDN) wird über eine Amazon CloudFront-Verteilung bereitgestellt, die außerdemdas Streamen von Mediendateien unterstützt (siehe Tutorials zum Streaming von Medien mit AmazonCloudFront).

66

https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/welcome.html

https://aws.amazon.com/documentation/s3/


https://aws.amazon.com/cloudfront/streaming/

https://aws.amazon.com/cloudfront/streaming/


Hosting und Streaming auf einen Blick

Konfigurierte AWS-Services und -Ressourcen • Amazon CloudFront - Content Delivery Network(Amazon CloudFront – Netzwerk für dieBereitstellung von Inhalten) (siehe AmazonCloudFront)

Konzepte | Konsole | Preise• Amazon S3-Bucket (siehe Amazon

S3 – Handbuch Erste Schritte <https://aws.amazon.com/cloudfront/pricing/>`__)



Weitere Informationen finden Sie unter Anzeigenvon für diese Funktion bereitgestellten AWS-Ressourcen (p. 69).


• Hosting von Web-App-Inhalt (Internetzugriff fürIhren Inhalt, keine Webserver erforderlich)

• AWS SDK for JavaScript (Aufrufen von AWS-Services über Standard-Scripting)

• Weltweites CDN (Weltweite Inhaltsverteilung undweltweites Streamen von Medien) CloudFrontbietet mehrere Optionen im Hinblick auf denregionalen Rahmen und die Kosten IhrerVerteilung. Weitere Informationen finden Sieunter Konfigurieren der Funktion für Hosting undStreaming (p. 68).

Web-App-Demo Beispiel

• AWS SDK for JavaScript und einebenutzerdefiniert generierte Konfigurationsdateiwerden in Ihrem Bucket bereitgestellt.

Weitere Informationen finden Sie unter Web-App-Unterstützung (p. 68).

Systemeigene Schnellstart-App-Demos Diese Funktion fügt einer von Mobile Hubgenerierten Schnellstart-App Folgendes hinzu:

• Anzeigen der Dateiliste im AWS-Speicher,Herunterladen und Anzeigen von Dateien sowieVerwalten von deren lokalem Cache

67

https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/


https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/HowCloudFrontWorks.html

https://console.aws.amazon.com/cloudfront/

https://aws.amazon.com/cloudfront/pricing/




https://console.aws.amazon.com/s3/

https://aws.amazon.com/s3/pricing/


Web-App-Unterstützung

Wenn Sie Hosting und Streaming aktivieren, stellt Mobile Hub im Stammverzeichnis Ihres Buckets einelokale Kopie von AWS SDK for JavaScript bereit.

Mobile Hub generiert außerdem die Projektkonfigurationsdateien aws-config.js und aws-exports.js,die die Endpunktkonstanten für alle AWS-Services enthalten, die Mobile Hub für Ihr Projekt konfiguriert hat.aws-exports.js wird für die Integration in ES6-kompatible Skriptsprachen wie Node.js bereitgestellt.Verwenden Sie diese Werte, um SDK-Aufrufe Ihrer Services von Ihrer gehosteten Web-App ausdurchzuführen.

Note

Was die Sicherheit betrifft, wird empfohlen, den Zugriff auf die Ressourcen einer App so weitals möglich zu reduzieren. Diese Konfigurationsdateien sind öffentlich zugänglich und enthaltenIDs für alle AWS-Ressourcen Ihrer App. Wenn es zum Design passt, wird empfohlen, IhreRessourcen dadurch zu schützen, dass nur authentifizierten Benutzern der Zugriff darauf erlaubtwird. Sie können dies in diesem Projekt tun, indem Sie die Mobile Hub-Funktion User Sign-in (Benutzeranmeldung) (p. 72) mit der Option Require sign-in (Anmeldung erforderlich)aktivieren.

Sie können auch die entsprechende Konfigurationsdatei in Ihre hybride systemeigene App/mobile Web-Appkopieren, um das Aufrufen Ihrer AWS-Services von Ihrer App aus mithilfe von JavaScript zu aktivieren.

Konfigurieren der Funktion für Hosting und Streaming

Themen• Durchsuchen Ihres Inhalts (p. 68)• Verwalten Ihrer App-Komponenten (p. 68)• Verwenden einer benutzerdefinierten Domäne für Ihre Web-App (p. 69)

Durchsuchen Ihres Inhalts

Wenn Hosting und Streaming aktiviert ist, haben Sie verschiedene Optionen:

• Launch from Amazon S3 (Über Amazon S3 starten): Diese Option ruft die nicht zwischengespeicherteDatei "index.html" im Stammverzeichnis Ihres Quell-Buckets auf.

• Launch from Amazon CloudFront (Über Amazon CloudFront starten): Diese Option ruft die Datei"index.html" auf, die in den CDN-Edge-Servern zwischengespeichert ist.

Note

Das Bereitstellen von Edge-Standorten für die Verteilung kann bis zu einer Stunde dauern.Dieser Link wird erst komplett ausgeführt, wenn die Verteilung die Propagierung im Netzwerkabgeschlossen hat.

• Manage files (Dateien verwalten): Diese Option öffnet die Amazon S3-Konsole zum Überprüfen undVerwalten des Inhalts Ihres Quell-Buckets. Sie können Ihren Bucket in der Amazon S3-Konsole auchfinden, indem Sie Ihr Projekt in Mobile Hub öffnen und dann auf der linken Seite das Symbol Resources(Ressourcen) auswählen. Der Name des für Hosting und Streaming konfigurierten Buckets enthält dieZeichenfolge hosting.

Verwalten Ihrer App-Komponenten

Sie haben eine Vielzahl an Möglichkeiten, Ihre Web-App-Komponenten mithilfe der Amazon S3-Konsole,der AWS-Befehlszeilenschnittstelle oder einer der vielen verfügbaren Drittanbieter-Anwendungen zuverwalten.

68

https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/welcome.html


Verwenden der Amazon S3-Konsole

Um die Amazon S3-Konsole für das Überprüfen, Hochladen, Verschieben oder Löschen der in IhremBucket gespeicherten Dateien zu verwenden, gehen Sie zur Amazon S3-Konsole und wählen Sieden Bucket aus, dessen Name Ihren Projektnamen enthält. Der Inhalt Ihrer Web-App befindet sich imStammordner.

Verwenden der AWS-CLI

Die AWS-CLI ermöglicht Ihnen, in Ihrem Bucket gespeicherte Dateien mithilfe der Befehlszeile zu prüfen,hochzuladen, zu verschieben oder zu löschen.

Informationen zur Installation und Konfiguration des AWS CLI-Clients finden Sie unter Einrichten mit derAWS-Befehlszeilenschnittstelle.

Beispielsweise können Sie mit dem sync-Befehl Dateien von Ihrem und in Ihren lokalen Ordner (source)sowie von Ihrem und in Ihren Bucket (destination) übertragen.

$ aws s3 sync {source destination} [--options]

Der folgende Befehl synchronisiert alle Dateien aus Ihrem aktuellen lokalen Ordner mit dem durch pathdefinierten Ordner im Bucket Ihrer Web-App.

$ aws s3 sync . s3://AWSDOC-EXAMPLE-BUCKET/path

Weitere Informationen über die Verwendung der AWS-CLI zum Verwalten von Amazon S3 finden Sie unterVerwenden von Amazon S3 mit der AWS-Befehlszeilenschnittstelle

Verwenden einer benutzerdefinierten Domäne für Ihre Web-App

Informationen zum Konfigurieren Ihres Hosting- und Streaming-CDN als Zieladresse Ihrerbenutzerdefinierten Domäne finden Sie unter Weiterleiten des Datenverkehrs zu einer Amazon CloudFront-Webverteilung mithilfe des Domänennamens.


Die folgende Abbildung zeigt den Mobile Hub-Bereich Resources (Ressourcen) mit Elementen, dienormalerweise für die Funktion für Hosting und Streaming bereitgestellt werden.

69

https://console.aws.amazon.com/s3/home



https://docs.aws.amazon.com/cli/latest/userguide/cli-s3.html

https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-cloudfront-distribution.html

https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-to-cloudfront-distribution.html



In der Mobile Hub-Schnellstart-App führt die Demo für das Hosting und Streaming eine Reihe vonAbbilddateien auf, die heruntergeladen und lokal zwischengespeichert und auf dem Gerät angezeigtwerden können. Der Benutzer kann die lokale Kopie der Abbilddatei auch löschen.

Conversational BotsWählen Sie die AWS Mobile Hub Conversational Bots-Funktion für mobile Backends für die folgendenZwecke:

• Hinzufügen einer Sprach- und Textoberfläche für das Verstehen natürlicher Sprache zu Ihrer App• Verwenden von natürlicher Sprache und Text, um mit Ihrer Geschäftslogik in der Cloud zu interagieren

Erstellen Sie ein kostenloses Mobile-Hub-Projekt und fügen Sie die Funktion "Conversational Bots" hinzu.

Funktionsdetails

Die folgende Abbildung zeigt Conversational Bots unter Verwendung von Amazon Lex, um einer mobilenApp-Schnittstelle natürliche Sprache hinzuzufügen, sowie als Integrationspunkt für andere Services.

70



AWS Mobile Hub Conversational Bots realisieren in Ihrer mobilen App das gleiche Verständnis für dienatürliche Sprache und die Integration von Geschäftslogik, das auch Amazon Alexa und Amazon Shoppingzu einem Sprach- und Textsteuerungserlebnis macht.

Mobile Hub Conversational Bots verwenden Amazon Lex, einen AWS-Service für den Aufbau vonSprach- und Sprachsteuerungsschnittstellen in Anwendungen. Amazon Lex verfügt über eine eingebauteIntegration in Lambda.

Mit Conversational Bots und Amazon Lex ist keine Deep-Learning-Kompetenz erforderlich. SpezifizierenSie den grundlegenden Gesprächsfluss in der Amazon Lex-Konsole, um einen Bot zu erstellen. DerService verwaltet die Dialoge und stimmt dynamisch die Antworten im Gespräch ab. Mit den Mobile HubConversation Bots können Sie Bots basierend auf Demonstrationsvorlagen oder Bots, die Sie in derAmazon Lex-Konsole erstellt haben, einrichten und testen. Mobile Hub bietet Integrationsanweisungen undbenutzerdefinierte Komponenten für die Wiederverwendung des Beispielcodes, den wir in Ihrer eigenenApp generieren.

Conversational Bots im Überblick

Konfigurierte AWS-Services und -Ressourcen • Amazon Lex (siehe Amazon LexEntwicklerhandbuch)

Konzepte | Konsole



• Erstellen und konfigurieren Sie ConversationalBots im Amazon Lex-Service auf Basis dermitgelieferten Demonstrationsvorlagen oderverwenden Sie die Amazon Lex-Konsole,um Ihre benutzerdefinierten Text- und/oderSprachinteraktionen in Ihre Anwendungeinzufügen.

• Integrieren Sie Ihre App, indem Sie denCode der Schnellstart-App herunterladen und

71

https://docs.aws.amazon.com/lex/latest/dg/what-is.html

https://docs.aws.amazon.com/lex/latest/dg/what-is.html

https://docs.aws.amazon.com/lex/latest/dg/how-it-works.html

https://console.aws.amazon.com/lex/home


wiederverwenden, ein Paket aus nativen iOS-und Android-SDKs sowie Hilfscode und Online-Hilfe, die alle dynamisch für Ihr Mobile Hub-Projekt erstellt werden.

Schnellstart-App-Demos Diese Funktion fügt einer von Mobile Hubgenerierten Schnellstart-App die folgendeFunktionalität hinzu:

• Ermöglicht dem Benutzer die Interaktion miteinem Conversational Bot, der mit Amazon Lexinteragiert.

Benutzeranmeldung



Wählen Sie die mobile Backend-Funktion von AWS Mobile Hub für die Benutzer-Anmeldung aus, um

• Fügen Sie Ihrer mobilen App die AWS-Benutzerauthentifizierung und sicheres Identity and AccessManagement hinzu.

Hinweis: Der sichere, nicht authentifizierte Zugriff auf AWS-Ressourcen ist für alle Mobile Hub-Projekte mit oder ohne die Funktion für dieBenutzeranmeldung verfügbar.

• Ihren Benutzern die Anmeldung für den Zugriff auf AWS-Ressourcen mit vorhandenenAnmeldeinformationen von Identitätsanbietern wie Facebook, Google, Microsoft Active Directory-Verbunddienste oder Ihrem eigenen benutzerdefinierten Benutzerverzeichnis ermöglichen.

Erstellen Sie ein kostenloses Mobile Hub-Projekt und fügen Sie die Funktion "User Sign-in" zurBenutzeranmeldung hinzu.

FunktionsdetailsDie folgende Abbildung zeigt eine Ressourcenzugriffsrichtlinie, die für einen nicht authentifizierten Benutzerumgesetzt wird.

72






Die folgende Abbildung zeigt eine Ressourcenzugriffsrichtlinie, die für einen authentifizierten Benutzerumgesetzt wird.

Mit dieser Funktion können Sie konfigurieren, wie Ihre Benutzer Zugriff auf AWS-Ressourcen undServices erhalten, die von Ihrer App verwendet werden. Dies kann ohne Anmeldungsprozess oder mitAuthentifizierung über einen oder mehrere Identitätsanbieter erfolgen. In beiden Fällen werden die AWS-Identitätserstellung und -Anmeldeinformationen über die Amazon Cognito-Identität bereitgestellt und dieAutorisierung des Zugriffs erfolgt über AWS Identity and Access Management (IAM).

Wenn Sie ein Projekt erstellen, stellt Mobile Hub die erforderliche AWS-Identität, Benutzerrolle undZugriffsrichtlinienkonfiguration bereit, um allen Benutzern Zugriff auf uneingeschränkte Ressourcen zuermöglichen. Wenn Sie Ihrer App die Funktion für die Benutzer-Anmeldung hinzufügen, können Sie denZugriff so beschränken, dass nur Benutzer zugelassen werden, die sich mit von einem Identitätsanbieterbestätigten Anmeldeinformationen anmelden, um geschützte Ressourcen zu verwenden. Über AmazonCognito-Identität erhält Ihr App-Benutzer AWS-Anmeldeinformationen, um direkt auf die AWS-Serviceszuzugreifen, die Sie für Ihr Mobile Hub-Projekt aktiviert und konfiguriert haben. Sowohl authentifiziertenals auch nicht authentifizierten Benutzern werden temporäre Anmeldeinformationen mit eingeschränktenBerechtigungen mit derselben Sicherheitsebene gewährt.

Amazon Cognito kann validierte Benutzeridentitäten von mehreren Identitätsanbietern zu einer einzigenAWS-Identität verbinden. Mit Mobile Hub können Sie Identitätsanbieter in Ihre mobile App integrieren,sodass sich Benutzer mit ihren vorhandenen Anmeldeinformationen von Facebook, Google und Ihremeigenen Identitätssystem anmelden können. Mit Amazon Cognito Eigene Benutzerpools können Sie auchIhr eigenes E-Mail- und Passwort-basiertes Benutzerverzeichnis erstellen und konfigurieren.

Die Funktion für die Benutzer-Anmeldung auf einen Blick

Konfigurierte AWS-Services und -Ressourcen • Amazon Cognito

Konzepte | Konsole | Preise• Amazon Cognito-Identitätspool

(siehe Verwenden von Verbundidentitäten)• Amazon Cognito: Ihre Benutzerpools

(siehe Erstellen und Verwalten vonBenutzerpools)

73

https://aws.amazon.com/cognito/dev-resources/

https://aws.amazon.com/iam/details/

https://docs.aws.amazon.com/cognito/latest/developerguide/concepts.html

https://console.aws.amazon.com/cognito/federated/

https://aws.amazon.com/cognito/pricing/

https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-identity.html

https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html

https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-identity-pools.html


• Amazon Cognito-SAML-Verbund

(siehe Übersicht über die Konfiguration desSAML 2.0-basierten Verbunds)

• IAM-Rolle und Sicherheitsrichtlinien (sieheKontrollieren des Zugriffs auf Mobile Hub-Projekte (p. 83))


Weitere Informationen finden Sie unter Anzeigenvon für diese Funktion bereitgestellten AWS-Ressourcen (p. 76).


Anmeldeanbieter (Benutzer erhalten mehr Zugriff,wenn sie sich anmelden)

• über Google-Authentifizierung (siehe Amazon Cognito Hosted UI verwenden)• über Facebook-Authentifizierung (siehe mobile-auth-setup)• Authentifizierung über E-Mail und Passwort (siehe Anbieter für die Benutzeranmeldung (p. 74))• Authentifizierung über SAML-Verbund (siehe Anbieter für die Benutzeranmeldung (p. 74))

Anmeldung ist erforderlich (authentifizierter Zugriff)

Anmeldung ist optional (Benutzer erhalten mehr Zugriff, wenn sie sich anmelden). Weitere Informationenfinden Sie unter Konfigurieren der Benutzeranmeldung (p. 74).• • Schnellstart-Demo-Funktionen

• Diese Funktion fügt einer von Mobile Hub generierten Schnellstart-App Folgendes hinzu:• Nicht authentifizierter Zugriff (sofern von der Konfiguration Ihrer App zugelassen), mit Anzeige der

ID, die AWS dem Gerät der App-Instance zuweist.• Anmeldebildschirm, der Benutzer anhand der ausgewählten Methode authentifiziert: Facebook,

Google oder E-Mail und Passwort (Ihr eigener Benutzerpool).• Optional Sign-in (Anmeldung ist optional) und Require Sign-in (Anmeldung ist erforderlich) sind

von der App bereitgestellte Zugriffsbarrieren für geschützte Ordner für nicht authentifizierteBenutzer.

Konfigurieren der Benutzer-Anmeldung

Für die Konfiguration der Anmeldeumgebung Ihrer Benutzer stehen die folgenden Optionen zur Verfügung.

Benutzer-Anmeldeanbieter

Facebook

• Um die Facebook-Benutzerauthentifizierung zu aktivieren, registrieren Sie Ihre Anwendung beiFacebook.

Wenn Sie bereits über eine registrierte Facebook-App verfügen, kopieren Sie die App-ID aus demFacebook Developers App Dashboard. Fügen Sie die ID in das Feld für Facebook-App-ID ein undwählen Sie Save Changes (Änderungen speichern) aus.

74

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html#CreatingSAML-configuring-IdP

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html#CreatingSAML-configuring-IdP

https://docs.aws.amazon.com/IAM/latest/UserGuide/

https://console.aws.amazon.com/iam/home#roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html#intro-features

https://docs.amplify.aws/sdk/auth/hosted-ui/q/platform/ios#using-amazon-cognito-hosted-ui


Wenn Sie noch keine Facebook-App-ID haben, müssen Sie eine erstellen, bevor Sie Facebook in Ihremobile App integrieren können. Das Facebook Developers-Portal führt Sie durch den Prozess derEinrichtung Ihrer Facebook-Anwendung.

Vollständige Anweisungen zur Integration Ihrer Anwendung in Facebook finden Sie unter Einrichten derFacebook-Authentifizierung.

Google

• Um Ihre Benutzer über Google zu authentifizieren, integrieren Sie Ihre Beispielanwendung vollständig inGoogle+ Anmeldung.

Wenn Sie bereits über ein registriertes Google Console-Projekt mit der Google+ API verfügen und eineWebanwendung OAuthClient und eine Client-ID für die Plattform Ihrer Wahl eingerichtet haben, kopierenSie die Google-Client-ID für Web-Apps und die Client-ID(s) von der Google Developers-Konsole undfügen Sie sie in diese Felder ein. Wählen Sie anschließend Save Changes (Änderungen speichern) aus.

Unabhängig von der Plattform, die Sie auswählen (Android oder iOS), müssen Sie mindestensFolgendes erstellen.• Ein Google-Konsolenprojekt mit aktivierter Google+ API (wird für die Google-Anmeldung verwendet)• Eine Webanwendungs-OAuth-Client-ID• Eine iOS- und/oder Android-Client-ID, je nachdem, welche Plattform Sie unterstützen

Vollständige Anweisungen zur Integration Ihrer Anwendung in Google+ finden Sie unter Einrichten derGoogle-Authentifizierung.

E-Mail und Passwort

• Wählen Sie die Anmeldung mit E-Mail und Passwort aus, wenn Sie Ihr eigenes, von AWS verwaltetesBenutzerverzeichnis und einen Anmeldeprozess für die Benutzer Ihrer App erstellen möchten.Konfigurieren Sie die Merkmale der Anmeldeumgebung wie folgt:• Wählen Sie die Optionen für die Benutzeranmeldung aus (E-Mail, Benutzername, und/oder

Telefonnummer)• Aktivieren Sie die Multifaktor-Authentifizierung (keine, erforderlich, optional), die die Übermittlung eines

Zugangscodes per SMS an das Telefon eines Benutzers und eine Aufforderung zur Eingabe diesesCodes zusammen mit dem anderen Faktor zur Anmeldung umfasst.

• Legen Sie die Passwortanforderungen fest (Mindestlänge, Groß-/Kleinschreibung, erlaubte Zahlenoder Sonderzeichen).

SAML-Verbund

• Mit SAML-Verbund können sich Benutzer mit Anmeldeinformationen in Ihrem vorhandenenIdentitätsspeicher mit ihrem gewohnten Benutzernamen und Passwort bei Ihrer mobilen App anmelden.Ein Benutzer meldet sich bei Ihrem Identitätsanbieter (IdP) an, der für die Rückgabe einer validierendenSAML-Zusicherung konfiguriert ist. Ihre App verwendet dann Amazon Cognito-Verbundidentitäten,um die SAML-Zusicherung gegen typische temporäre Anmeldeinformationen mit eingeschränktenBerechtigungen für den Zugriff auf Ihre AWS-Backend-Services auszutauschen.

SAML 2.0 (Security Assertion Markup Language 2.0) ist ein offener Standard, der von vielen IdPsverwendet wird, einschließlich Microsoft Active Directory Federation Service und Shibboleth. Ihr IdPmuss SAML 2.0-kompatibel sein, um diese Mobile Hub-Option nutzen zu können. Um einen Verbundzwischen AWS und Ihrem IdP zu bilden, müssen die beiden Systeme SAML-Verbundmetadatenaustauschen. AWS-Verbundmetadaten finden Sie unter https://signin.aws.amazon.com/static/saml-metadata.xml. Diese XML-Datei veranschaulicht die Form, die die Metadaten Ihres IdPs haben sollten.

75

https://developers.facebook.com/docs/facebook-login

https://developers.facebook.com/docs/facebook-login

https://developers.google.com/+/web/signin/

https://developers.google.com/+/web/signin/

https://signin.aws.amazon.com/static/saml-metadata.xml

https://signin.aws.amazon.com/static/saml-metadata.xml


Weitere Informationen zu SAML-Verbundmetadaten für Ihren IdP finden Sie unter Integrieren vonexternen SAML-Lösungsanbietern mit AWS.

So implementieren Sie diesen Austausch:1. Schlagen Sie in der Dokumentation des Identitätsanbieters nach, wie die AWS-

Verbundmetadatendatei verwendet wird, um AWS als Serviceanbieter zu registrieren.2. Stellen Sie sicher, dass das Mobile Hub-Projekt so konfiguriert ist, dass die Anmeldung per E-Mail-

Adresse und Passwort zum Erstellen eines Amazon Cognito-Benutzerpools verwendet werden kann.3. Konfigurieren Sie den Identitätsanbieter für den Benutzerpool mit den Schritten unter Erstellen von

SAML-Identitätsanbietern für einen Benutzerpool.

Weitere Informationen dazu, wie AWS den SAML-Verbund unterstützt, finden Sie unter Übersicht überdie Konfiguration des SAML 2.0-basierten Verbunds.

Anforderung für die Benutzeranmeldung

Anmeldung ist optional

• Benutzer haben die Möglichkeit, sich bei Ihrem ausgewählten Anmeldeidentitätsanbieter anzumelden(authentifizieren) oder sie können die Anmeldung überspringen (nicht authentifiziert). Ihre App erhältvon Amazon Cognito Identity temporäre Anmeldeinformationen für den Zugriff mit eingeschränktenBerechtigungen als authentifizierter Benutzer oder nicht authentifizierter Gastbenutzer, damit Ihre Appsicher auf Ihre AWS-Services zugreifen kann.

Anmeldung ist erforderlich

• Benutzer müssen sich bei einem der von Ihnen gewählten Anmeldeanbietern anmelden. Ihre App erhältvon Amazon Cognito Identity temporäre Anmeldeinformationen für den Zugriff mit eingeschränktenBerechtigungen als authentifizierter Benutzer, damit Ihre App sicher auf Ihre AWS-Services zugreifenkann.

Note

Wenn die Benutzeranmeldung nicht erforderlich ist, können nicht authentifizierte Benutzer aufDaten in Ihren Datenbanktabellen und Dateien in Ihren Speicher-Buckets zugreifen, es sei denn,diese Ressourcen sind explizit durch einen anderen Mechanismus beschränkt.

Benutzeranmeldung und AWS Identity and Access Management (IAM)

Beim Speichern Ihrer mobilen App erstellt Mobile Hub ein Amazon Cognito-Identitäten-Pool und eineneue IAM-Rolle. Diese werden verwendet, um temporäre AWS-Anmeldeinformationen für die Benutzerder Schnellstart-App zu generieren, damit sie auf Ihre AWS-Ressourcen zugreifen können. Die AWS-Sicherheitsrichtlinien für IAM-Rollen werden auf der Grundlage der aktivierten Anmeldefunktionenaktualisiert.

Nun ist Ihr mobiles Projekt für die Benutzeranmeldung eingerichtet. Jeder ausgewählte Identitätsanbieterwurde dem Anmeldebildschirm der Schnellstart-App hinzugefügt.

Weitere Informationen finden Sie unter Kontrollieren des Zugriffs auf Mobile Hub-Projekte (p. 83).


Die folgende Abbildung zeigt den Mobile Hub-Bereich Resources (Ressourcen) mit Elementen, dienormalerweise für die Funktion für die Benutzeranmeldung bereitgestellt werden.

76

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml_3rd-party.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml_3rd-party.html

https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-saml-idp.html

https://docs.aws.amazon.com/cognito/latest/developerguide/cognito-user-pools-saml-idp.html





In der Mobile Hub-Schnellstart-App können Benutzer in der Benutzeranmeldungs-Demo Funktionenverwenden, die auf AWS-Ressourcen ohne Authentifizierung oder mit Anmeldung in der App überIdentitätsanbieter wie Facebook, Google, SAML-Verbund bzw. E-Mail und Passwort zugreifen.

Wenn Sie Ihrem Projekt die Benutzer-Anmeldung mithilfe der Option Optional Sign-in (OptionaleAnmeldung) hinzufügen, wird bei Auswählen der Schnellstart-Anmelde-Demo der App die Amazon CognitoIdentitäten-Pool-ID des Benutzers zurückgegeben und angezeigt. Diese ID ist mit dem Gerät der App-Instance verknüpft, das aktuell auf AWS-Ressourcen zugreift.

Wenn Sie Ihrem Projekt die Benutzer-Anmeldung mithilfe der Option Required Sign-in (ErforderlicheAnmeldung) hinzufügen, wird bei Auswählen der Schnellstart-Anmelde-Demo der App das Aussehen derAnmeldeumgebung jenem des/der im Projekt konfigurierten Identitätsanbieter entsprechend gestaltet.Durch die Anmeldung bei der Demo wird der Benutzer im ausgewählten Identitätsanbieterdienstauthentifiziert und die Amazon Cognito Identitäten-Pool-ID des Benutzers zurückgegeben und angezeigt.

User File Storage



Verwenden Sie AWS Mobile Hub User File Storage für Folgendes:

• Hinzufügen von Cloud-Speicherplatz für Benutzerdateien, Profildaten und den Status von Anwendungenzu Ihrer mobilen App

77




• Verwendung einer detaillierten Kontrolle des Zugriffs auf Dateien und Daten durch die Implementierungvier gängiger Muster von Berechtigungsrichtlinien

Suchen Sie nach Amazon Cognito Sync? Amazon Cognito Sync wurde eingestellt. WennSie eine Lösung zur Datensynchronisierungzwischen Geräten in Echtzeit sowie integrierteOfflinefunktionen benötigen, beachten Sie AWSAppSync.

Erstellen Sie ein kostenloses Mobile Hub-Projekt und fügen Sie die User File Storage-Funktion hinzu.

Funktionsdetails

Die Mobile Hub-Funktion User Data Storage erstellt und konfiguriert vier Ordner für jeden Benutzer ineinem Amazon Simple Storage Service (Amazon S3)-Bucket der App.

Best Practice für App-Sicherheit ist es, nur den minimalen Zugriff auf Ihre Buckets zu ermöglichen, die dasDesign Ihrer App unterstützen. Jeder der vier bereitgestellten Ordner hat eine Richtlinie, die verschiedenezugeordnete Berechtigungsoptionen darstellt. Zusätzlich bietet Mobile Hub die Option, den Zugriff auf IhreApp mithilfe der Funktion User Sign-in (Benutzeranmeldung) (p. 72) auf authentifizierte Benutzer zubeschränken.

Hinweis: Wenn Sie die Funktion User Sign-in (Benutzeranmeldung) (p. 72) nicht als Required(Erforderlich) konfigurieren, haben nicht authentifizierte Benutzer Lese- und/oder Schreibzugriff auf Daten,falls sie nicht durch eine Ordner- oder Bucket-Zugriffsrichtlinie daran gehindert werden.

Die folgende Tabelle zeigt die Details der Berechtigungsrichtlinien, die für jeden Ordnertyp bereitgestelltwerden.

Ordnername Eigentümerberechtigungen Berechtigungen aller anderen

Öffentlich Lesen/Schreiben Lesen/Schreiben

Privat Lesen/Schreiben Keine

Geschützt Lesen/Schreiben Nur Lesen

Uploads Nur Schreiben Nur Schreiben

Die folgende Abbildung zeigt, wie die IAM-Richtlinie zur Kontrolle des Dateizugriffs in einem geschütztenOrdner angewendet wird. Die Richtlinie gewährt Lese-/Schreibberechtigungen für den Benutzer, der denOrdner erstellt hat, und Leseberechtigungen für alle anderen Benutzer.

78

https://aws.amazon.com/appsync/

https://aws.amazon.com/appsync/



Die User File Storage-Funktion ermöglicht es Ihnen, Benutzerdateien wie Fotos oder Dokumente in derCloud zu speichern und Benutzerprofildaten wie App-Einstellungen oder Spielstatus in Schlüssel/Wert-Paaren zu speichern. Wenn Sie diese Funktion auswählen, wird ein Amazon S3-Bucket als Speicherorterstellt, in dem Ihre App Benutzerdateien speichert.

User File Storage im Überblick

Konfigurierte AWS-Services und -Ressourcen • Amazon S3-Bucket (siehe Amazon S3 –Handbuch Erste Schritte)


Mobile Hub-fähige Funktionen verwenden AmazonCognito für die Authentifizierung und IAM für dieAutorisierung. Weitere Informationen finden Sieunter User Sign-in (Benutzeranmeldung) (p. 72).Weitere Informationen finden Sie unter Anzeigenvon für diese Funktion bereitgestellten AWS-Ressourcen (p. 80).

Konfigurationsoptionen Diese Funktion aktiviert die folgendenKonfigurationsoptionen des mobilen Backends:

• Benutzerdateien und App-Daten mit AmazonS3 speichern. Wenn Sie User File Storageaktivieren, werden vier Ordner mit jeweilseiner eigenen Zugriffsrichtlinienkonfigurationbereitgestellt:• private - Jeder Benutzer der mobilen

App kann in diesem Ordner eigene Dateienerstellen, lesen, aktualisieren und löschen.Kein anderer App-Benutzer kann auf diesenOrdner zugreifen.

• protected - Jeder Benutzer der mobilenApp kann in diesem Ordner eigene Dateienerstellen, lesen, aktualisieren und löschen.Außerdem kann jeder App-Benutzer dieDateien anderer App-Benutzer in diesemOrdner lesen.

79

https://docs.aws.amazon.com/AmazonS3/latest/dev/Introduction.html

https://docs.aws.amazon.com/AmazonS3/latest/gsg/

https://docs.aws.amazon.com/AmazonS3/latest/gsg/



https://aws.amazon.com/s3/pricing/


• public? Jeder Benutzer der App kann indiesem Ordner eigene Dateien erstellen,lesen, aktualisieren und löschen.

Schnellstart-Demo-Funktionen Diese Funktion fügt einer von Mobile Hubgenerierten Schnellstart-App Folgendes hinzu:

• Der Datei-Explorer für den S3-Bucket der Apperlaubt es dem Benutzer:• Hochladen und Anzeigen von Dateien in jedem

Public-Ordner.• Anzeigen und Herunterladen von Dateien

in einem Private-Ordner, den der Benutzererstellt hat.

• Anzeigen und Herunterladen von Dateien ineinem Protected-Ordner, den irgendjemanderstellt hat, und Hochladen von Dateien indiesen Ordner, wenn der Benutzer ihn erstellthat.

• Hochladen von Dateien in beliebige Uploads-Ordner. Die Benutzereinstellung desgewählten Farbthemas kann in der Cloudbeibehalten werden und aus der Cloudabgerufen werden.


Die folgende Abbildung zeigt den Mobile Hub-Bereich Resources (Ressourcen) mit den normalerweise fürdie User File Storage-Funktion bereitgestellten Elementen.

80

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchNutzung von IAM

Nutzung von AWS Identity and Access Management inAWS Mobile Hub



Note

Es sind keine fundierten Kenntnisse der AWS IAM-Authentifizierung und -Zugriffssteuerungerforderlich, um mithilfe von Mobile Hub ein Backend für eine mobile App zu konfigurieren.

• Steuern des Zugriffs auf Mobile Hub-Projekte (p. 83): Erfahren Sie, wie Berechtigungen zumKonfigurieren Ihres Mobile Hub-Projekts erteilt werden.

• Berechtigungsmodell für Mobile Hub-Projekte (p. 81): Informationen zu den Berechtigungen, die SieMobile Hub für den Zugriff auf AWS-Ressourcen und -Services erteilen können.

• IAM-Authentifizierung und Zugriffssteuerung für Mobile Hub (p. 87): Informationen zurAuthentifizierung und Zugriffssteuerung in IAM und AWS.

Berechtigungsmodell für Mobile Hub-Projekte



Wichtig

Um Mobile Hub-Projekte in einem Konto ändern zu können, muss dem BenutzerAdministratorberechtigungen von einem Kontoadministrator gewährt werden (p. 84). Lesen Sie diesenAbschnitt mit weiteren Informationen.

Wenn Sie ein Benutzer sind, der zusätzliche Berechtigungen für ein Projekt benötigt, wenden Siesich an den Administrator des betreffenden AWS-Kontos. Wenden Sie sich an [email protected], wenn Sie Unterstützung im Zusammenhang mit dem neuen Berechtigungsmodellbenötigen.

Themen• Berechtigungsmodell für Mobile Hub (p. 82)• Was geschieht, wenn ich derzeit MobileHub_Service_Role verwende, um Mobile Hub-Berechtigungen

zu gewähren? (p. 82)• Warum wurde das Berechtigungsmodell geändert? (p. 82)

81





mailto:[email protected]?subject=Mobile%20Hub%20project%20permissions

mailto:[email protected]?subject=Mobile%20Hub%20project%20permissions


Berechtigungsmodell für Mobile Hub

Derzeit verwendet das Mobile Hub-Berechtigungsmodell die Berechtigungen der Benutzer direkt, wenndiese Operationen in der Mobile Hub-Konsole oder der Befehlszeilenschnittstelle ausführen. DiesesModell bietet Kontoadministratoren eine fein abgestufte Zugriffskontrolle in Bezug auf die Operationen, dieihre Benutzer im Konto ausführen können, unabhängig davon, ob sie Mobile Hub, die Konsole oder dieBefehlszeilenschnittstelle einsetzen, um direkt mit Services zu interagieren.

Um Projekte ändern zu können, benötigen Benutzer Berechtigungen zur Nutzung von Mobile Hub (gewährtdurch die IAM-Richtlinie AWSMobileHubFullAccess). Außerdem benötigen sie das Recht, all jene Aktionenauszuführen, die Mobile Hub in ihrem Namen durchführt. In nahezu jedem Fall bedeutet dies, dass einKontoadministrator dem Benutzer die Richtlinie AdministratorAccess gewähren (p. 84) muss, um denZugriff auf die AWS-Ressourcen zu ermöglichen, die Mobile Hub ändert. Der Grund besteht darin, dassMobile Hub bei Änderungen der Projekteinstellungen die IAM-Rollen und -Richtlinien modifiziert, die zumAktivieren der Funktionen verwendet werden und von diesen Einstellungen betroffen sind. Indem BenutzerIAM-Rollen und -Richtlinien ändern, kontrollieren sie den Zugriff auf Ressourcen im Konto. Zu diesemZweck benötigen sie Administratorberechtigungen.

Wenn Administratoren keine Administratorberechtigungen für das gesamte Konto gewähren möchten,können sie stattdessen für jeden Benutzer bzw. jedes Team mit AWS Organizations (p. 85) eineigenes Unterkonto bereitstellen. Innerhalb ihrer Unterkonten verfügen die Benutzer über volleAdministratorberechtigungen. Besitzer von Unterkonten werden nur durch die Richtlinie eingeschränkt, dievon ihrem Administrator definiert wird. Die Fakturierung erfolgt über das übergeordnete Konto.

Was geschieht, wenn ich derzeit MobileHub_Service_Role verwende, um MobileHub-Berechtigungen zu gewähren?

Bisher hat Mobile Hub eine Servicerolle namens MobileHub_Service_Role unterstellt, umServicekonfigurationen für Sie unter Verwendung der folgenden verwalteten Richtlinie zu ändern:

https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/service-role/AWSMobileHub_ServiceUseOnly

In jenem älteren Modell wurde zum Ändern von Mobile Hub-Projekten nur die Berechtigung zum Aufrufender Mobile Hub-APIs über die Konsole oder die Befehlszeile benötigt. Administratoren konnten dieseBerechtigung delegieren, indem sie die Richtlinie AWSMobileHub_FullAccess einem AWS IAM-Benutzerbzw. einer entsprechenden Gruppe oder Rolle anfügten.

Wenn das Konto des Mobile Hub-Projekts auf dem alten Modell basiert, ergeben sich folgendeAuswirkungen auf Benutzer, denen die Berechtigung AdministratorAccess nicht gewährt wird.

• IAM-Benutzer, -Gruppen und -Rollen mit der Richtlinie AWSMobileHub_FullAccess verfügen nichtmehr über ausreichende Berechtigungen, um mutierende Operationen in Mobile Hub – über die Konsoleoder mit awsmobile in der Befehlszeilenschnittstelle (CLI) – vorzunehmen.

• Damit IAM-Benutzer, -Gruppen oder -Rollen mutierende Operationen unter Verwendung von MobileHub vornehmen können, benötigen sie die erforderlichen Berechtigungen. Administratoren haben diebeiden folgenden Möglichkeiten, Benutzern die Berechtigung zu gewähren (p. 83), alle verfügbarenOperationen in Mobile Hub aufzurufen: fügen Sie die Richtlinie AdministratorAccess an denBenutzer an (bzw. eine Rolle, der die Benutzer angehören, oder eine Gruppe, deren Mitglied dieBenutzer sind) oder AWS Organizations verwenden, um Berechtigungen zu verwalten.

Warum wurde das Berechtigungsmodell geändert?

AWS Mobile Hub erstellt IAM-Rollen und weist ihnen Berechtigungen zu, um die Nutzung von AWS-Ressourcen in Mobilgeräte-Apps zu ermöglichen. Solche Operationen werden als administrativ betrachtet,weil sie auch die Berechtigung zur Durchführung von Operationen an Ressourcen im Konto einschließen.

82



https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html


Zuvor stellte die Servicerolle von Mobile Hub-Benutzern, denen AWSMobileHub_FullAccess-Berechtigungen gewährt wurden, einen Pfad zur Eskalation der eigenen Rechte zur Handhabung vonRessourcen bereit. Dies geschah potenziell auf Wegen, die von den jeweiligen Administratoren nichtvorgesehen waren. Durch Entfernen der Servicerolle wird der Pfad zum Eskalieren von Rechten entfernt,sodass die Kontrolle der Benutzerberechtigungen direkt in die Hände des für ein Mobile Hub-Projektzuständigen Administrators gelangt.

Kontrollieren des Zugriffs auf Mobile Hub-Projekte



Übersicht

In diesem Abschnitt werden zwei verschiedene Methoden zum Steuern des Zugriffs auf Mobile Hub-Projekte beschrieben:

• Erteilen von Administratorberechtigungen für das Konto (p. 84)

Einzelnen Entwicklern oder Gruppen mit einfachen Anforderungen bezüglich der Segmentierungdes Zugriffs auf ihre Mobile Hub-Projekte können die erforderlichen Berechtigungen gewährtwerden, indem die von AWS verwaltete Richtlinie AdministratorAccess (p. 86) oderAWSMobileHub_ReadOnly (p. 86) dem gewünschten Benutzer, einer Rolle, die dem Benutzerzugeordnet ist, oder einer Gruppe, deren Mitglied der Benutzer ist, zugewiesen wird.

Oder:

• Verwenden von AWS Organizations zum Verwalten der Berechtigungen (p. 85)

Bei Organisationen, die eine fein abgestufte Zugriffssteuerung und Kostenverfolgung für ihre Mobile Hub-Projekte benötigen, können AWS-Kontoadministratoren Unterkonten bereitstellen und die Richtlinien fürihre Benutzer festlegen.

Informationen darüber, wie Mobile Hub einem Benutzer zugeordnete IAM-Richtlinien verwendet, umServices im Namen eines Benutzers zu erstellen, finden Sie unter Projektberechtigungsmodell vonMobile Hub (p. 81).

Weitere Informationen zu AWS Identity and Access Management (IAM) finden Sie unter IAM-Authentifizierung und Zugriffssteuerung für Mobile Hub (p. 87) und IAM-Authentifizierung undZugriffssteuerung für Mobile Hub (p. 87).

Bewährte Methode: IAM-Benutzer für den Zugriff auf AWS erstellen

Zur Verbesserung der Sicherheit wird empfohlen, dass Sie Ihr AWS-Stammkonto nicht für den Zugriff aufMobile Hub verwenden. Erstellen Sie stattdessen einen neuen AWS Identity and Access Management(IAM)-Benutzer in Ihrem AWS-Konto (oder verwenden Sie einen vorhandenen IAM-Benutzer) undgreifen Sie über diesen Benutzer auf Mobile Hub zu. Weitere Informationen finden Sie unter AWS-Sicherheitsanmeldeinformationen in der Allgemeinen Referenz zu AWS.

83



https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html

https://docs.aws.amazon.com/general/latest/gr/aws-security-credentials.html


Sie können mit der IAM-Konsole einen IAM-Benutzer für sich selbst oder einen Delegatbenutzer erstellen.Erstellen Sie zunächst eine IAM-Administratorengruppe und anschließend einen neuen IAM-Benutzer.Fügen Sie diesen Benutzer der Gruppe hinzu.

Note

Bevor ein IAM-Benutzer in einem Konto ein Mobile Hub-Projekt erstellen kann, muss ein Benutzermit Administratorrechten für das Konto zur Mobile Hub-Konsole navigieren und ein erstes Projekterstellen. Mit diesem Schritt wird bestätigt, dass Mobile Hub die AWS-Services in Ihrem Namenverwalten kann.Weitere Informationen zur Zuweisung von Zugriffsrechten für IAM-Benutzer oder -Gruppen findenSie unter IAM-Authentifizierung und Zugriffskontrolle für Mobile Hub (p. 87).

Erteilen von Berechtigungen für Mobile Hub-Projekte

Themen• Erstellen eines neuen IAM-Benutzers im Konto und Gewähren von Mobile Hub-

Berechtigungen (p. 84)• Erstellen einer IAM-Gruppe (p. 85)• Erteilen von Mobile Hub-Berechtigungen für einen vorhandenen Kontobenutzer (p. 85)

Gehen Sie wie nachfolgend beschrieben vor, um eine Gruppe und/oder Benutzer zu erstellen und diesenBenutzern Zugriff auf die Mobile Hub-Projekte zu gewähren.

Informationen zum Zuweisen von Berechtigungen zu einer Rolle finden Sie unter Hinzufügen vonBerechtigungen im AWS IAM-Benutzerhandbuch.

Erstellen eines neuen IAM-Benutzers im Konto und Gewähren von Mobile Hub-Berechtigungen

1. Öffnen Sie die IAM-Konsole. Klicken Sie im linken Bereich auf Users (Benutzer) und dann auf Add User(Benutzer hinzufügen).

2. Geben Sie einen Benutzernamen ein und aktivieren Sie die Kontrollkästchen Programmaticaccess (Programmgesteuerter Zugriff) und AWS Management Console access (AWS-Managementkonsolenzugriff).

3. Wählen Sie die gewünschte Passwortrichtlinie aus. Wählen Sie dann Next: Permissions aus.4. Wählen Sie auf der Registerkarte Add user to group (Benutzer zu Gruppe hinzufügen) die Gruppe

Administrators (Administratoren) oder Read_Only (Nur Lesezugriff) für den Benutzer aus, und klicken Sieauf Next: Review (Nächster Schritt: Prüfen).

Danach werden Optionen zum Anpassen des Benutzerpassworts, zum Benachrichtigen des Benutzersüber das neue Konto per E-Mail und zum Herunterladen der Zugriffsschlüssel-ID, des Schlüsselwertsund des Passworts angezeigt.

5. Wählen Sie Create user aus.6. So wenden Sie die Richtlinie an:

• Wenn Sie eine Gruppe zum Verwalten der Projektberechtigungen erstellt haben, klicken Sie auf Adduser to group (Benutzer zu Gruppe hinzufügen), wählen Sie die Gruppe aus und klicken Sie danachauf Next: Review (Nächster Schritt: Prüfen) und auf Create User (Benutzer erstellen).

Oder:• Wenn Sie die Projektberechtigungen pro Benutzer verwalten, klicken Sie auf Attach existing

policies directly (Vorhandene Richtlinien direkt zuordnen), wählen Sie die gewünschte Richtlinie aus(AdministratorAccess oder AWSMobileHub_ReadOnly) und klicken Sie auf Create user (Benutzererstellen).

84


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#w2ab1c19c19c26b9

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_change-permissions.html#w2ab1c19c19c26b9



Erstellen einer IAM-Gruppe

1. Melden Sie sich bei der IAM an und öffnen Sie die AWS Management-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie im Navigationsbereich Groups (Gruppen) und dann Create New Group (Neue Gruppeerstellen) aus.

3. Geben Sie im Feld Group Name (Gruppenname) einen Namen für die Gruppe ein, z. B.Administrators oder Read_Only. Klicken Sie anschließend auf Next Step (Nächster Schritt).

4. Aktivieren Sie in der Liste von Richtlinien entweder das Kontrollkästchen der RichtlinieAdministratorAccess (vollständige Berechtigungen für die Gruppe) oder der RichtlinieAWSMobileHub_ReadOnly (nur Lesezugriff). Über das Menü Filter (Filtern) und das Feld Search(Suchen) können Sie die Liste filtern.

5. Wählen Sie Next Step (Nächster Schritt) und anschließend Create Group (Gruppe erstellen) aus. Ihreneue Gruppe wird unter Group Name aufgeführt.

Erteilen von Mobile Hub-Berechtigungen für einen vorhandenen Kontobenutzer

1. Klicken Sie im linken Bereich auf Policies (Richtlinien).2. Klicken Sie auf den Link der gewünschten verwalteten Richtlinie (AdministratorAccess oder

AWSMobileHub_ReadOnly).3. Wählen Sie Attached Entities (Angefügte Entitys) aus.4. Wählen Sie Attach (Anfügen) aus.5. Wählen Sie die Benutzer, Rollen oder Gruppen aus, denen Sie Berechtigungen erteilen möchten.6. Wählen Sie Attach Policy aus.

Verwenden von AWS Organizations zum Verwalten der Berechtigungen

AWS Organizations kann verwendet werden, um Berechtigungen für Gruppen zu verwalten, die den Zugriffauf ihre Mobile Hub-Projekte segmentieren müssen. So kann ein Administrator beispielsweise für jedenEntwickler in einem Team ein Konto erstellen. Innerhalb des eigenen Kontos würde dann jeder Benutzerüber die vom Administrator gewährten Berechtigungen verfügen. Die erforderlichen Schritte sind:

1. Wenn Sie noch kein AWS-Konto besitzen, registrieren Sie sich für das kostenlose Kontingent für AWS.2. Erstellen Sie in der AWS Organizations-Konsole eine Organisation.3. Erstellen Sie für die Benutzer in der Organisation neue Konten bzw. fügen Sie vorhandene Konten hinzu.4. Laden Sie die Benutzer ein.5. Erstellen Sie eine Organisationseinheit für die Entwickler.6. Ordnen Sie den Mitgliedern der Einheit eine Richtlinie zu.

Die zugeordnete Richtlinie wird innerhalb des Geltungsbereichs des AWS-Kontos eines Benutzersangewendet. Sie können den Zugriff auf Services und Funktionen einschränken, die nicht für die Arbeitmit Mobile Hub benötigt werden. Die folgende Richtlinie erteilt beispielsweise alle in der verwaltetenRichtlinie FullAWSAccess festgelegten Berechtigungen, schließt aber den Zugriff auf den AmazonEC2-Service aus.

"Statement": [ { "Effect": "Allow", "Action": "*", "Resource": "*" }, { "Effect": “Deny”,

85



https://docs.aws.amazon.com/organizations/latest/userguide/orgs_introduction.html


https://console.aws.amazon.com/organizations/


"Action": “ec2:*”, "Resource": "*" }]

Eine schrittweise Anleitung finden Sie im Tutorial unter Erstellen und Verwalten einer AWS Organization.

Von AWS verwaltete (vordefinierte) Richtlinien für den Zugriff auf Mobile Hub-Projekte

Der AWS Identity and Access Management-Service steuert Benutzerberechtigungen für AWS-Servicesund -Ressourcen. Es sind bestimmte Berechtigungen erforderlich, um die Konfiguration für Projekte mitAWS Mobile Hub anzuzeigen und zu ändern. Diese Berechtigungen wurden in den folgenden verwaltetenRichtlinien, die Sie einem IAM-Benutzer, einer &IAM;-Rolle bzw. Gruppe anfügen können, gruppiert.

• AdministratorAccess

Diese Richtlinie gewährt unbegrenzten Zugriff auf die AWS-Services im Konto. Dies schließt denLese- und Schreibzugriff auf AWS Mobile Hub-Projekte ein. Benutzer, deren IAM-Benutzer, -Rolleoder -Gruppe diese Richtlinie angefügt ist, können neue Projekte erstellen, die Konfiguration fürvorhandene Projekte ändern und Projekte und Ressourcen löschen. Diese Richtlinie enthält zudemalle Berechtigungen, die unter der verwalteten Richtlinie AWSMobileHub_ReadOnly zulässig sind.Nachdem Sie sich bei der Mobile Hub-Konsole angemeldet und ein Projekt erstellt haben, können Sieden folgenden Link verwenden, um diese Richtlinie und die IAM-Identitäten anzuzeigen, die ihr angefügtsind.• https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn:aws:iam::aws:policy/

AdministratorAccess$jsonEditor

• AWSMobileHub_ReadOnly

Diese Richtlinie bietet Lesezugriff auf AWS Mobile Hub-Projekte. Benutzer, deren IAM-Benutzer, -Rolleoder -Gruppe diese Richtlinie angefügt ist, können die Projektkonfiguration anzeigen und Beispiel-Schnellstart-App-Projekte erstellen, die heruntergeladen und auf dem Desktop eines Entwicklerskompiliert werden können (z. B. in Android Studio oder Xcode). Diese Richtlinie ermöglicht keineÄnderungen an der Mobile Hub-Projektkonfiguration und ermöglicht es dem Benutzer nicht, dieVerwendung von AWS Mobile Hub in einem Konto zu aktivieren, in dem es noch nicht aktiviert wurde.Nachdem Sie sich bei der Mobile Hub-Konsole angemeldet und ein Projekt erstellt haben, können Sieden folgenden Link verwenden, um diese Richtlinie und die IAM-Identitäten anzuzeigen, die ihr angefügtsind.• http://console.aws.amazon.com/iam/home?region=us-east-1#policies/arn:aws:iam::aws:policy/

AWSMobileHub_ReadOnly

Wenn Ihr IAM-Benutzer, -Rolle oder Gruppe über Leseberechtigungen für die Verwendung in einemAWS Mobile Hub-Projekt verfügt, werden in den Projektinformationen, die Sie in der Konsole sehen,keine außerhalb von Mobile Hub vorgenommenen Änderungen angezeigt. Wenn Sie beispielsweiseeine Cloud Logic-API im API Gateway entfernen, kann sie in der Liste der Cloud Logic-Funktionen IhresMobile Hub-Projekts immer noch vorhanden sein, bis ein Benutzer mit mobilehub:SynchronizeProject-Berechtigungen die Konsole besucht. Benutzer, denen der Zugriff auf die Konsole mit der RichtlinieAdminstratorAccess gewährt wird, verfügen über diese Berechtigungen. Wenn Sie in Mobile Hubzusätzliche Berechtigungen benötigen, wenden Sie sich an den Administrator und fordern Sie dieRichtlinie AdminstratorAccess an.

86

https://alpha-docs-aws.amazon.com/organizations/latest/userguide/orgs_tutorials_basic.html

https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn:aws:iam::aws:policy/AdministratorAccess$jsonEditor

https://console.aws.amazon.com/iam/home?region=us-east-1#/policies/arn:aws:iam::aws:policy/AdministratorAccess$jsonEditor

https://console.aws.amazon.com/iam/home?region=us-east-1#policies/arn:aws:iam::aws:policy/AWSMobileHub_ReadOnly

https://console.aws.amazon.com/iam/home?region=us-east-1#policies/arn:aws:iam::aws:policy/AWSMobileHub_ReadOnly


IAM-Authentifizierung und -Zugriffskontrolle für Mobile Hub



Note


Mobile Hub verwendet AWS-Anmeldeinformationen und -Berechtigungsrichtlinien, um Benutzern dasAnzeigen und/oder Erstellen und Konfigurieren der Backend-Funktionen zu ermöglichen, die Benutzer fürihre Mobilgeräte-App auswählen.

In den folgenden Abschnitten erfahren Sie, wie IAM funktioniert, wie Sie mithilfe von IAM den Zugriff aufIhre Projekte sicher steuern können und welche IAM-Rollen und Richtlinien Mobile Hub in Ihrem Namenkonfiguriert.

Themen• Authentifizierung (p. 87)• Zugriffskontrolle (p. 88)

AuthentifizierungAWS-Ressourcen und -Services können nur mit der richtigen Authentifizierung unter Verwendung vonAWS-Anmeldeinformationen (denen auch Zugriffsberechtigungen (p. 89) für diese Ressourcen undServices gewährt werden müssen) angezeigt, erstellt oder geändert werden. Sie können mit einer derfolgenden Identitäten auf AWS zugreifen:

• Stammbenutzer des AWS-Kontos

Wenn Sie sich bei AWS anmelden, geben Sie eine mit Ihrem AWS-Konto verknüpfte E-Mail-Adresse unddas Passwort ein. Dies sind Ihre Root-Anmeldeinformationen. Sie bieten vollständigen Zugriff auf alleIhre AWS-Ressourcen.

Important

Aus Sicherheitsgründen empfehlen wir, die Root-Anmeldeinformationen nur zum Erstelleneines Administratorbenutzers zu verwenden. Hierbei handelt es sich um einen IAM-Benutzermit vollständigen Berechtigungen für Ihr AWS-Konto. Anschließend können Sie mit diesemAdministratorbenutzer andere IAM-Benutzer und -Rollen mit eingeschränkten Berechtigungenerstellen. Weitere Informationen finden Sie unter Bewährte Methoden für IAM und Erstelleneines Administratorbenutzers und einer Gruppe im IAM-Benutzerhandbuch.

• IAM-Benutzer

Ein IAM-Benutzer ist eine Identität in Ihrem AWS-Konto mit bestimmten benutzerdefiniertenBerechtigungen (z. B. Leseberechtigungen für den Zugriff auf Ihr Mobile Hub-Projekt). Sie können einenIAM-Benutzernamen und ein Passwort für die Anmeldung bei sicheren AWS-Webseiten wie der AWSManagement Console, AWS-Diskussionsforen oder dem AWS Support-Center verwenden.

Zusätzlich zu einem Benutzernamen und Passwort können Sie Zugriffsschlüssel für jeden Benutzererstellen. Verwenden Sie diese Schlüssel, wenn Sie programmgesteuert auf AWS-Services zugreifen,

87



https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#create-iam-users

https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html


https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://console.aws.amazon.com/

https://console.aws.amazon.com/


https://console.aws.amazon.com/support/home#/

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html


und zwar entweder in einem der folgenden SDKs oder über die AWS-Befehlszeilenschnittstelle(Command Line Interface, CLI). Das SDK und die CLI-Tools verwenden die Zugriffsschlüssel, um IhreAnfrage verschlüsselt zu signieren. Wenn Sie die AWS-Tools nicht nutzen, müssen Sie die Anforderungselbst signieren.

• IAM-Rolle

Eine IAM-Rolle ist eine weitere IAM-Identität, die Sie in Ihrem Konto mit bestimmten Berechtigungenerstellen können. Sie ähnelt einem IAM-Benutzer, ist aber nicht mit einer bestimmten Person verknüpft.Eine IAM-Rolle ermöglicht Ihnen, temporäre Zugriffsschlüssel zu erhalten, mit denen Sie auf die AWS-Services und -Ressourcen zugreifen können. IAM-Rollen mit temporären Anmeldeinformationen sind infolgenden Situationen hilfreich:• Zugriff für verbundene Benutzer

Statt einen IAM-Benutzer zu erstellen, können Sie bereits vorhandene Benutzeridentitäten vomBenutzerverzeichnis Ihres Unternehmens oder von einem Web-Identitätsanbieter verwenden. Diesewerden als verbundene Benutzer bezeichnet. AWS weist einem verbundenen Benutzer eine Rolle zu,wenn der Zugriff über einen Identitätsanbieter angefordert wird. Weitere Informationen zu verbundenenBenutzern finden Sie unter Verbundene Benutzer und Rollen im IAM-Benutzerhandbuch.

• Kontenübergreifender Zugriff

Sie können eine IAM-Rolle in Ihrem Konto verwenden, um einem anderen AWS-Konto Berechtigungenfür den Zugriff auf die Ressourcen Ihres Kontos zu erteilen. Ein Beispiel finden Sie im Tutorial:Delegieren des Zugriffs in allen AWS-Konten mithilfe von IAM-Rollen im IAM-Benutzerhandbuch.

• Zugriff auf AWS-Services

Sie können eine IAM-Rolle in Ihrem Konto verwenden, um einem AWS-Service Berechtigungen für denZugriff auf die Ressourcen Ihres Kontos zu erteilen. Sie können beispielsweise eine Rolle erstellen,mit der Amazon Redshift in Ihrem Namen auf einen Amazon S3-Bucket zugreifen und die im Bucketgespeicherten Daten in einen Amazon Redshift-Cluster laden kann. Weitere Informationen findenSie unter Erstellen einer Rolle zum Delegieren von Berechtigungen an einen AWS-Service im IAM-Benutzerhandbuch.

• Anwendungen, die auf Amazon EC2 ausgeführt werden

Statt Zugriffsschlüssel in der EC2-Instance zu speichern, die von Anwendungen zum Ausführen inder Instance und zum Stellen von AWS-API-Anforderungen verwendet werden, können Sie eineIAM-Rolle verwenden, um temporäre Anmeldeinformationen für diese Anwendungen zu verwalten.Erstellen Sie ein Instance-Profil, das an die Instance angefügt ist, um eine AWS-Rolle zu einer EC2-Instance zuzuweisen und die Rolle für sämtliche Anwendungen der Instance bereitzustellen. EinInstance-Profil enthält die Rolle und ermöglicht, dass Programme, die in der EC2 Instance ausgeführtwerden, temporäre Anmeldeinformationen erhalten. Weitere Informationen finden Sie im Thema zumVerwenden von Rollen für Anwendungen in Amazon EC2 im IAM-Benutzerhandbuch.

Zugriffskontrolle

Sie können über gültige Anmeldeinformationen zur Authentifizierung Ihrer Anfragen verfügen, jedochkönnen Sie auf ein Mobile Hub-Projekt nur mit entsprechenden Berechtigungen zugreifen bzw. es ändern.Das Gleiche gilt für Mobile Hub, wenn es Services und Ressourcen erstellt und konfiguriert, die Sie für IhrProjekt konfiguriert haben.

In den folgenden Abschnitten wird beschrieben, wie Sie Berechtigungen verwalten und diejenigenverstehen, die von Mobile Hub in Ihrem Namen verwaltet werden.

• Kontrollieren des Zugriffs auf Mobile Hub-Projekte (p. 83)

88

https://aws.amazon.com/tools/

https://aws.amazon.com/cli/

https://aws.amazon.com/cli/

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/tutorial_cross-account-with-roles.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2.html


Übersicht über die Verwaltung von Zugriffsberechtigungen fürMobile Hub-Projekte



Note


Jede AWS-Ressource gehört einem AWS-Konto. Die Berechtigungen zum Anzeigen und Erstellen vonRessourcen oder für den Zugriff darauf (p. 83) werden durch Richtlinien geregelt.

Ein Kontoadministrator kann IAM-Identitäten (d. h. Benutzer, Gruppen und Rollen) Berechtigungsrichtlinienzuweisen. Manche Services (z. B. AWS Lambda) unterstützen auch die Zuweisung vonBerechtigungsrichtlinien zu Ressourcen.

Note

Ein Kontoadministrator (oder Administratorbenutzer) ist ein Benutzer mit Administratorrechten.Weitere Informationen finden Sie unter Bewährte Methoden für IAM im IAM-Benutzerhandbuch.Beim Erteilen von Berechtigungen entscheiden Sie, wer die Berechtigungen erhält, für welcheRessourcen die Berechtigungen gelten und welche Aktionen an diesen Ressourcen gestattetwerden sollen.

Themen• Grundlegendes zum Eigentum an Ressourcen für AWS Mobile Hub (p. 89)• Verwalten des Zugriffs auf Ressourcen (p. 90)• Angeben der Richtlinienelemente: Aktionen, Effekte, Ressourcen und Prinzipale (p. 91)

Grundlegendes zum Eigentum an Ressourcen für AWS Mobile Hub

Die primäre Ressource eines Mobile Hub-Projekts ist das Projekt selbst. Bei der ersten Verwendung derMobile Hub-Konsole erlauben Sie Mobile Hub Berechtigungen zu verwalten und auf die Projektressourcefür Sie zuzugreifen. Bei dem AWS-Konto, das die Ressource erstellt hat, handelt es sich um denRessourcen-Eigentümer. Genauer gesagt ist der Ressourceneigentümer das AWS-Konto der Prinzipal-Entität (d. h. das Root-Konto, ein IAM-Benutzer oder eine IAM-Rolle), welche die Anforderung, die dieRessource erstellt, authentifiziert. Die Funktionsweise wird anhand der folgenden Beispiele deutlich:

• Wenn Sie die Anmeldeinformationen des Stammkontos für Ihr AWS-Konto verwenden, um ein AWSMobile Hub-Projekt zu erstellen, ist Ihr AWS-Konto der Eigentümer der mit dem Projekt verknüpftenRessourcen.

• Wenn Sie einen IAM-Benutzer in Ihrem AWS-Konto erstellen und diesem Berechtigungen zum Erstelleneines Mobile Hub-Projekts erteilen, kann dieser Benutzer auch Projekte erstellen. Eigentümer der mitdem Projekt verknüpften Ressourcen ist jedoch das AWS-Konto, zu dem der Benutzer gehört.

• Wenn Sie in Ihrem AWS-Konto eine IAM-Rolle mit Berechtigungen zum Erstellen von AWS Mobile Hub-Projekten einrichten, kann jeder, der die Rolle übernimmt, Projekte erstellen, bearbeiten oder löschen.Eigentümer der mit dem Projekt verknüpften Ressourcen ist Ihr AWS-Konto, zu dem die Rolle gehört.

89



https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html


Verwalten des Zugriffs auf RessourcenEine Berechtigungsrichtlinie beschreibt, wer Zugriff auf welche Objekte hat. Im folgenden Abschnitt werdendie verfügbaren Optionen zum Erstellen von Berechtigungsrichtlinien erläutert.

Note

Dieser Abschnitt behandelt die Verwendung von IAM im Zusammenhang mit AWS MobileHub. Er enthält keine detaillierten Informationen über den IAM-Service. Eine umfassende IAM-Dokumentation finden Sie unter Was ist IAM? im IAM-Benutzerhandbuch. Informationen überdie IAM-Richtliniensyntax und Beschreibungen finden Sie in der AWS Identity and AccessManagement-Richtlinienreferenz im IAM-Benutzerhandbuch.

Richtlinien, die einer IAM-Identität zugeordnet sind, werden als identitätsbasierte Richtlinien (IAM-Richtlinien) bezeichnet, während Richtlinien, die einer Ressource zugeordnet sind, als ressourcenbasierteRichtlinien bezeichnet werden.

Themen• Identitätsbasierte Richtlinien (IAM-Richtlinien) (p. 90)• Ressourcenbasierte Richtlinien (p. 91)

Identitätsbasierte Richtlinien (IAM-Richtlinien)

Richtlinien können IAM-Identitäten zugewiesen werden. Sie können z. B. Folgendes tun:

• Anfügen von Berechtigungsrichtlinien zu Benutzern oder Gruppen in Ihrem Konto: Ein Kontoadministratorkann eine Berechtigungsrichtlinie verwenden, die einem bestimmten Benutzer zugeordnet ist, um diesemBenutzer Berechtigungen zum Erstellen eines AWS Mobile Hub-Projekts zu erteilen.

• Einer Rolle eine Berechtigungsrichtlinie zuweisen (kontoübergreifende Berechtigungen erteilen): Siekönnen einer IAM-Rolle eine identitätsbasierte Berechtigungsrichtlinie zuweisen, um kontoübergreifendeBerechtigungen zu erteilen. Wenn Sie zum Beispiel den Mobile Hub zum ersten Mal öffnen undals Kontoprinzipal zustimmen, ihm Berechtigungen für die Bereitstellung und Konfiguration IhresProjekts zu erteilen, erteilen Sie der von AWS verwalteten MobileHub_Service_Role-Rollekontoübergreifende Berechtigungen. Im Rahmen Ihres Mobile Hub-Projekts wird eine von AWSverwaltete Richtlinie, AWSMobileHub_ServiceUseOnly, dieser Rolle angefügt. Die Rolle verfügtüber eine Vertrauensrichtlinie, die es Mobile Hub ermöglicht, als Kontoprinzipal zu fungieren undBerechtigungen für von Ihrem Projekt verwendete Services und Ressourcen erteilen zu können.

Weitere Informationen zum Delegieren von Berechtigungen mithilfe von IAM finden Sie im ThemaZugriffsverwaltung im IAM-Benutzerhandbuch.

Als Beispiel für die Verwendung einer identitätsbasierten Richtlinie erteilt die folgende Richtlinieeinem Benutzer Berechtigungen zum Erstellen eines Amazon S3-Buckets. Ein Benutzer mit diesenBerechtigungen kann mithilfe des Amazon S3-Service einen Speicherort erstellen.

{ "Version":"2012-10-17", "Statement":[ { "Effect":"Allow", "Action":"s3:CreateBucket*", "Resource":"*" } ] }

Weitere Informationen zur Verwendung von identitätsbasierten Richtlinien mit Mobile Hub finden Sie unterreference-mobile-hub-project-permissions-model.

90

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchRegionales Projektservicehosting

Weitere Informationen zu Benutzern, Gruppen, Rollen und Berechtigungen finden Sie im Thema Identitäten(Benutzer, Gruppen und Rollen) im IAM-Benutzerhandbuch.

Ressourcenbasierte Richtlinien

Andere Services, z. B. Amazon S3, unterstützen auch ressourcenbasierte Berechtigungsrichtlinien.Beispielsweise können Sie einem Amazon S3-Bucket eine Richtlinie zuweisen, um dieZugriffsberechtigungen für diesen Bucket zu verwalten.

Angeben der Richtlinienelemente: Aktionen, Effekte, Ressourcen und PrinzipaleJeder von Mobile Hub konfigurierte Service definiert eine Reihe von API-Operationen. Um Mobile HubBerechtigungen für diese API-Operationen zu erteilen, wird eine Reihe von Aktionen in einer von AWSverwalteten Richtlinie angegeben. Für das Durchführen einer API-Operation können Berechtigungen fürmehrere Aktionen erforderlich sein.

Grundlegende Richtlinienelemente:

• Ressource – In einer Richtlinie wird der Amazon-Ressourcenname (ARN) zur Identifizierung derRessource verwendet, für die die Richtlinie gilt.

• Aktion – Mit Aktionsschlüsselwörtern geben Sie die Ressourcenoperationen an, die Sie zulassen oderverweigern möchten. Beispielsweise erlaubt es die s3:Createbucket-Berechtigung Mobile Hub, dieAmazon S3CreateBucket-Operation durchzuführen.

• Auswirkung – Die von Ihnen festgelegte Auswirkung, wenn ein Benutzer die jeweilige Aktion anfordert –entweder "Allow" (Zugriffserlaubnis) oder "Deny" (Zugriffsverweigerung). Wenn Sie den Zugriff auf eineRessource nicht ausdrücklich gestatten („Allow“), wird er automatisch verweigert. Sie können den Zugriffauf eine Ressource auch explizit verweigern. So können Sie sicherstellen, dass Benutzer nicht daraufzugreifen können, auch wenn der Zugriff durch eine andere Richtlinie gestattet wird.

• Prinzipal – In identitätsbasierten Richtlinien (IAM-Richtlinien) ist der Benutzer, dem die Richtliniezugewiesen ist, automatisch der Prinzipal. In ressourcenbasierten Richtlinien müssen Sie den Benutzer,das Konto, den Service oder die sonstige Entität angeben, die die Berechtigungen erhalten soll (gilt nurfür ressourcenbasierte Richtlinien).

Hosting in bestimmten Regionen für Mobile Hub-Projekte



Die Konfigurationseinstellungen Ihres Mobile Hub-Projekts sind in der AWS-Region USA Ost (Virginia)gespeichert.

Die AWS-Services, die Sie konfigurieren, werden in der Region gehostet, die Sie für Ihr Projekt auswählen,sofern sie für diese Region verfügbar sind. Wenn ein Service in dieser Region nicht verfügbar ist, hostetMobile Hub ihn in einer anderen Region.

Weitere Informationen zu regionalen Endpunkten finden Sie unter Regionen und Endpunkte von AWS.

Wenn Sie wissen möchten, wo die Services für Ihr Projekt gehostet werden, suchen Sie in den folgendenTabellen nach der Region Ihres Projekts.

91

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id.html



https://docs.aws.amazon.com/general/latest/gr/rande.html


Wählen Sie die Region Ihres Projekts aus:• USA Ost (Virginia) (p. 92)• USA Ost (Ohio) (p. 92)• USA West (Kalifornien) (p. 93)• USA West (Oregon) (p. 93)• EU West (Irland) (p. 93)• EU West (London) (p. 94)• EU (Frankfurt) (p. 94)• Asien-Pazifik (Tokio) (p. 95)• Asien-Pazifik (Seoul) (p. 95)• Asien-Pazifik (Mumbai) (p. 95)• Asien-Pazifik (Singapur) (p. 96)• Asien-Pazifik (Sydney) (p. 96)• Südamerika (São Paulo) (p. 96)

USA Ost (Virginia)

Hosting für diese Services: In Region:

Amazon API Gateway (Cloud-Logik) USA Ost (Virginia)

Amazon Cognito (Benutzeranmeldung/User FileStorage)

USA Ost (Virginia)

Amazon DynamoDB (NoSQL-Datenbank) USA Ost (Virginia)

Amazon Lex (Conversational Bots) USA Ost (Virginia)

Amazon Pinpoint (Messaging und Analysen) USA Ost (Virginia)

Amazon S3 (User File Storage/Messaging undHosting)

USA Ost (Virginia)

AWS Lambda (Cloud-Logik) USA Ost (Virginia)

USA Ost (Ohio)


Amazon API Gateway (Cloud-Logik) USA Ost (Ohio)


USA Ost (Ohio)

Amazon DynamoDB (NoSQL-Datenbank) USA Ost (Ohio)



92




USA Ost (Ohio)

AWS Lambda (Cloud-Logik) USA Ost (Ohio)

USA West (Kalifornien)


Amazon API Gateway (Cloud-Logik) USA West (Kalifornien)


USA West (Oregon)

Amazon DynamoDB (NoSQL-Datenbank) USA West (Kalifornien)




USA West (Kalifornien)

AWS Lambda (Cloud-Logik) USA West (Kalifornien)

USA West (Oregon)


Amazon API Gateway (Cloud-Logik) USA West (Oregon)


USA West (Oregon)

Amazon DynamoDB (NoSQL-Datenbank) USA West (Oregon)




USA West (Oregon)

AWS Lambda (Cloud-Logik) USA West (Oregon)

EU West (Irland)


Amazon API Gateway (Cloud-Logik) EU West (Irland)

93




EU West (Irland)

Amazon DynamoDB (NoSQL-Datenbank) EU West (Irland)




EU West (Irland)

AWS Lambda (Cloud-Logik) EU West (Irland)

EU West (London)


Amazon API Gateway (Cloud-Logik) EU West (London)


EU West (London)

Amazon DynamoDB (NoSQL-Datenbank) EU West (London)




EU West (London)

AWS Lambda (Cloud-Logik) EU West (London)

EU (Frankfurt)


Amazon API Gateway (Cloud-Logik) EU (Frankfurt)


EU (Frankfurt)

Amazon DynamoDB (NoSQL-Datenbank) EU (Frankfurt)




EU (Frankfurt)

AWS Lambda (Cloud-Logik) EU (Frankfurt)

94


Asien-Pazifik (Tokio)


Amazon API Gateway (Cloud-Logik) Asien-Pazifik (Tokio)



Amazon DynamoDB (NoSQL-Datenbank) Asien-Pazifik (Tokio)





AWS Lambda (Cloud-Logik) Asien-Pazifik (Tokio)

Asien-Pazifik (Seoul)


Amazon API Gateway (Cloud-Logik) Asien-Pazifik (Seoul)



Amazon DynamoDB (NoSQL-Datenbank) Asien-Pazifik (Seoul)





AWS Lambda (Cloud-Logik) Asien-Pazifik (Seoul)

Asien-Pazifik (Mumbai)


Amazon API Gateway (Cloud-Logik) Asien-Pazifik (Mumbai)



Amazon DynamoDB (NoSQL-Datenbank) Asien-Pazifik (Mumbai)



95





AWS Lambda (Cloud-Logik) Asien-Pazifik (Mumbai)

Asien-Pazifik (Singapur)


Amazon API Gateway (Cloud-Logik) Asien-Pazifik (Singapur)



Amazon DynamoDB (NoSQL-Datenbank) Asien-Pazifik (Singapur)





AWS Lambda (Cloud-Logik) Asien-Pazifik (Singapur)

Asien-Pazifik (Sydney)


Amazon API Gateway (Cloud-Logik) Asien-Pazifik (Sydney)



Amazon DynamoDB (NoSQL-Datenbank) Asien-Pazifik (Sydney)





AWS Lambda (Cloud-Logik) Asien-Pazifik (Sydney)

Südamerika (São Paulo)


Amazon API Gateway (Cloud-Logik) Südamerika (São Paulo)

96

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchFehlersuche in Projekten



USA Ost (Virginia)

Amazon DynamoDB (NoSQL-Datenbank) Südamerika (São Paulo)




USA Ost (Virginia)

AWS Lambda (Cloud-Logik) Südamerika (São Paulo)

Fehlersuche im Mobile Hub-Projekt



Die folgenden Abschnitte beschreiben beim Konfigurieren sowie beim Im- und Exportieren von Mobile Hub-Projekten möglicherweise auftretende Probleme und zugehörige Abhilfemaßnahmen.

Themen• Eine API kann nicht importiert werden (p. 97)• Eine NoSQL-Tabelle kann nicht importiert werden (p. 98)• Mehrere NoSQL-Tabellen können nicht importiert werden (p. 98)• Push-Anmeldeinformationen können nicht importiert werden (p. 99)• Build-Artefakte wurden nicht gefunden (p. 99)• Konfigurieren des S3-Buckets nicht möglich während (p. 100)• "Administrator Required (Administrator erforderlich)"-Fehler während der Einrichtung (p. 100)• Kontoeinrichtung unvollständig (p. 100)• Datei zu groß zum Importieren (p. 101)

Eine API kann nicht importiert werdenFehlermeldung

• Project owner does not own existing API : arn:aws:execute-api:us-east-1:012345678901:abcdefghij.

(dabei ist die API-ID arn:aws:execute-api:us-east-1:012345678901:abcdefghij spezifisch für dasimportierte Projekt)

Beschreibung

97




• Diese Meldung bedeutet, dass die API mit der angezeigten ID nicht importiert werden kann, da sie imaktuellen AWS-Konto nicht existiert. Dies geschieht, wenn die APIs im ursprünglichen Projekt außerhalbder Mobile Hub Cloud Logic-Funktion erstellt und dann importiert wurden.

Abhilfe

• Um diese Situation zu beheben, gehen Sie wie folgt vor.1. Ändern Sie die YAML der zu importierenden Projektdefinition, indem Sie die Abschnitte unter dem

features:components-Knoten entfernen, die mit dem Namen einer API beginnen, die in die CloudLogic-Funktion des ursprünglichen Projekts importiert wurde.

2. Speichern und importieren Sie die Projektdefinition.3. Aktivieren Sie die Mobile Hub Cloud Logic-Funktion in Ihrem importierten Projekt und erstellen Sie die

API und ihren Handler neu.

Eine NoSQL-Tabelle kann nicht importiert werdenFehlermeldung

• Es gibt bereits eine DynamoDB-Tabelle namens "someprojectname-mobilehub-012345678-TableName"in Ihrem Konto. Bitte wählen Sie einen anderen Namen oder entfernen Sie die bestehende Tabelle undversuchen Sie es erneut.

(dabei ist der Tabellenname someprojectname-mobilehub-012345678-TableName spezifisch für dasimportierte Projekt)

Beschreibung

• Diese Meldung erscheint, wenn Sie ein Projekt importieren, das die NoSQL-Datenbankfunktion enthält.Sie weist darauf hin, dass die Amazon DynamoDB-Tabelle in der Projektkonfiguration bereits existiert.Dies kann auftreten, wenn in der Projektdefinitionsdatei ein YAML tablename-Wert bearbeitet wurde undmehr als ein Versuch unternommen wird, ihn in dasselbe Konto zu importieren.

Abhilfe

• Um diese Situation zu beheben, gehen Sie wie folgt vor1. Ändern Sie tablename-Werte, um den Konflikt aufzulösen.2. Speichern und importieren Sie die Projektdefinition.3. Passen Sie den Code der importierten App an der Stelle an, an der er auf den alten tablename-Wert

verweist.

Mehrere NoSQL-Tabellen können nicht importiert werdenFehlermeldung

• Projektdatei(en) kann/können nicht decodiert werden. Sie enthalten möglicherweise Daten, dievon einem anderen Konto verschlüsselt wurden. Push-Funktion konnte nicht decodiert werden.Anmeldeinformationsattribut konnte nicht dekodiert werden.

Beschreibung

98


• Diese Meldung erscheint, wenn Sie Anmeldeinformationen für den Messaging-Service für Push-Benachrichtigungen oder Amazon SNS-Themen-IDs für Funktionen importieren, die nicht Ihrem AWS-Konto zugeordnet sind.

Abhilfe

• Um diese Situation zu beheben, gehen Sie wie folgt vor1. Ändern Sie die YAML der importierten Projektdefinition, indem Sie Tabellendefinitionsabschnitte

entfernen.2. Speichern und importieren Sie die Projektdefinition.3. Verwenden Sie die von Ihnen entfernten Tabellendefinitionen, um diese Tabellen mit der Mobile Hub

NoSQL Database-Funktion manuell zu erstellen.

Push-Anmeldeinformationen können nicht importiert werdenFehlermeldung

• Projektdatei(en) kann/können nicht decodiert werden. Sie enthalten möglicherweise Daten, dievon einem anderen Konto verschlüsselt wurden. Push-Funktion konnte nicht decodiert werden.Anmeldeinformationsattribut konnte nicht dekodiert werden.

Beschreibung

• Diese Meldung erscheint, wenn Sie Anmeldeinformationen für den Messaging-Service für Push-Benachrichtigungen oder Amazon SNS-Themen-IDs für Funktionen importieren, die nicht Ihrem AWS-Konto zugeordnet sind.

Abhilfe

• Um diese Situation zu beheben, gehen Sie wie folgt vor1. Ändern Sie die YAML der importierten Projektdefinition, indem Sie den push:-Knoten entfernen.2. Speichern und importieren Sie die Projektdefinition.3. Aktivieren Sie die Mobile Hub Push-Benachrichtigungen oder die Nutzer-Engagement-Funktion unter

Verwendung Ihrer eigenen Anmeldeinformationen und Themen für den Messaging-Service.

Build-Artefakte wurden nicht gefundenFehlermeldung

• Build-Artefakt-Uploads/exported-project-definition.zip im Amazon S3 Bucket archive-deployments-mobilehub-0123456789 für project-name wurden nicht gefunden.

dabei sind exported-project-definition, der numerische Teil der Amazon S3-Bucket-ID und der project-name spezifisch für das importierteProjekt)

Beschreibung

• Diese Meldung tritt auf, wenn ein Projektimport fehlschlägt, weil Mobile Hub die Datei einer Cloud-Logic-API-Handler-Funktion (Lambda) nicht finden kann, die in der .yml-Projektdefinitionsdatei angegeben ist.

Abhilfe

99


• Um diese Situation zu beheben, gehen Sie wie folgt vor

Die Abhilfe für diese Situation besteht darin, den Speicherort der Lambda-Datei(en) an den in der YAML-Projektdefinition angegebenen Pfad anzupassen.

Der Fehler tritt auf, wenn aus irgendeinem Grund der Pfad, der im codeFilename:-Schlüssel in derYAML beschrieben ist, nicht mit dem tatsächlichen Speicherort der Lambda-Funktionsdatei relativ zumStammverzeichnis des ...-deployments-... Amazon S3-Buckets übereinstimmt, den Mobile Hubbei aktivierter Cloud Logic bereitstellt.

Konfigurieren des S3-Buckets nicht möglich währendFehlermeldung

• It looks like there was a problem creating or configuring your S3 bucket. (Es scheint ein Problem beimErstellen oder Konfigurieren des S3-Buckets aufgetreten zu sein.)

Beschreibung

• Mobile Hub konnte im Rahmen des Mobile Hub-Projektimports keinen S3-Bucket für dieBereitstellungsartefakte des Projekts erstellen.

Abhilfe

• Führen Sie die folgenden Schritte als Abhilfemaßnahme durch

Prüfen Sie mit der Amazon S3-Konsole, ob die maximale Bucketkapazität erreicht wurde.

"Administrator Required (Administrator erforderlich)"-Fehlerwährend der EinrichtungFehlermeldung

• It looks like you do not have permission for this operation. (Ihnen fehlt die für diese Operationerforderliche Berechtigung.)

Beschreibung

• Der Benutzer verfügt im Rahmen der Konfiguration eines Mobile Hub-Projekts nicht über dieBerechtigung zum Erstellen der erforderlichen Mobile Hub-Servicerolle.

Abhilfe

• Führen Sie die folgenden Schritte als Abhilfemaßnahme durch

Kontaktieren Sie einen Administrator für das AWS-Konto und lassen Sie ihn die Servicerolle an folgenderStelle erstellen: https://console.aws.amazon.com/mobilehub/home#/activaterole/.

Kontoeinrichtung unvollständigFehlermeldung

• It looks like your AWS account is not fully set up. (Ihr AWS-Konto wurde nicht vollständig eingerichtet.)

100


https://console.aws.amazon.com/mobilehub/home#/activaterole/

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchExportieren und Importieren von Projekten

Beschreibung

• Dieser Fehler kann aus einer Reihe von Gründen im Rahmen der Mobile Hub-Projektkonfigurationauftreten.

Abhilfe

• Führen Sie die folgenden Schritte als Abhilfemaßnahme durch• Melden Sie sich von der AWS-Konsole ab und schließen Sie alle Browserfenster. Melden Sie sich

dann bei<problematic>`AWS Mobile console <>`__</problematic>an und versuchen Sie, die ursprünglich den Fehler auslösende Operation durchzuführen.

• Tritt das Problem weiterhin auf, erstellen Sie im<problematic>`AWS Mobile Development forum<https://forums.aws.amazon.com/forum.jspa?forumID=88>`__</problematic>einen Beitrag, um Support zu erhalten.

Datei zu groß zum ImportierenFehlermeldung

• Die Projektdatei ist zu groß. Die maximale Dateigröße beträgt 10 MB.

Beschreibung

• Diese Meldung erscheint, wenn Sie versuchen, eine Projektdefinitionsdatei mit mehr als 10 MB zuimportieren.

Abhilfe

• Reduzieren Sie die Größe der Projektexportdatei. Projektexporteure möchten möglicherweisegroße Datei-Nutzlasten außerhalb ihrer Projektdefinitionsdateien bereitstellen und den ImporteurenAnweisungen zur Verwendung von AWS-Konsolen zur Einbindung dieser zugehörigen Dateien geben.

Importieren und Exportieren von AWS Mobile Hub-Projekten



ÜbersichtMobile Hub bietet die Möglichkeit, YAML-Dateien zu exportieren und zu importieren, die die KonfigurationIhres Mobile Hub-Projekts beschreiben. Jeder Benutzer mit einem AWS-Konto kann eine exportierteProjektkonfigurationsdatei importieren, um ein neues Projekt mit neuen AWS-Ressourcen bereitzustellen,die der importierten Konfiguration entsprechen.

101




Mit dieser Funktion können Sie die AWS-Service-Konfiguration eines exportierten Projekts replizieren.Während die Daten in den Tabellen eines Projekts nicht exportiert werden, können Dateien in Speicher-oder Hosting-Buckets und API-Handler-Funktionscode manuell zu Ihrer exportierten Projektdefinitionhinzugefügt werden. Weitere Informationen finden Sie im import-export-manual.

So exportieren Sie eine Projektkonfigurationsdatei

1. Navigieren Sie in der Mobile Hub-Konsole zu Ihrer Projektliste.2. Bewegen Sie den Mauszeiger über die Ellipsen (drei Punkte) oben rechts auf der Projektkarte.3. Wählen Sie oben rechts auf der Karte Export (file) ((Datei) exportieren) für das Projekt, das Sie

exportieren wollen.4. Speichern Sie Ihre Projektexportdatei.

Weitere Informationen zum Inhalt einer exportieren Projektkonfigurationsdatei finden Sie unter Struktureiner YML-Datei des Projektexports (p. 106).

Ein Projekt importieren

1. Navigieren Sie in der Mobile Hub-Konsole zu Ihrer Projektliste.2. Wählen Sie links oben auf der Seite Import your project (Projekt importieren) aus.3. Verschieben Sie eine Projektdefinitionsdatei in das Dialogfeld Import project configuration

(Projektkonfiguration importieren).4. Wählen Sie Import project (Projekt importieren) aus.

Freigeben Ihrer Projektkonfiguration mit einem "Deploy to AWSMobile Hub"-LinkIn jedem öffentlichen GitHub-Repository können Sie einen Link bereitstellen, der die Erstellung eines neuenMobile Hub-Projekts sofort einleitet, wenn Sie die exportierte Projektkonfigurationsdatei importieren, die imQuerystring des Links definiert ist. Der Link sollte die folgende Form haben:

https://console.aws.amazon.com/mobilehub/home?#/?config=YOUR-MOBILE-HUB-PROJECT-CONFIGURATION-LOCATION

Beispielsweise erstellt der folgende HTML-Code einen Link, der eine sofortige Konfiguration der AWSBackend-Services einer App bereitstellt, basierend auf Mobile Hub-Funktionen, die in react-sample.zipdefiniert sind. Die Ausführung dieses Codes finden Sie in der README.md für das AWS Mobile ReactSample.

<p align="center">

102

https://github.com/awslabs/aws-mobile-react-sample



<a target="_blank" href="https://console.aws.amazon.com/mobilehub/home?#/?config=https://github.com/awslabs/aws-mobile-react-sample/blob/master/backend/import_mobilehub/react-sample.zip"> <span> <img height="100%" src="https://s3.amazonaws.com/deploytomh/button-deploy-aws-mh.png"/> </span> </a></p>

Der Querystring-Abschnitt des Links kann an den Speicherort einer Mobile Hub-Projektkonfigurationsdateimobile-hub-project.yml oder einer .zip-Projektexportdatei mit einer mobile-hub-project.yml-Datei verweisen.

Important

Wenn Sie eine .zip-Datei verwenden, muss diese der Struktur und dem Inhalt entsprechen, diefür einen Mobile Hub-Projektkonfigurationsimport erforderlich ist. Detaillierte Informationen findenSie unter Struktur einer ZIP-Datei des Projektexports (p. 105).

Einschränkungen beim Import von ProjektenThemen

• Maximale Projektdefinitionsdateigröße 10 MB (p. 103)• Projektkomponenten, die einen manuellen Export erfordern (p. 103)• Kontenübergreifende Anmeldeinformationen (p. 104)• Nicht exportierte Projektkomponenten (p. 104)

Maximale Projektdefinitionsdateigröße 10 MB

Ein Import von .zip- oder .yml-Dateien eines Mobile Hub-Projekts mit mehr als 10 MB wird nichtunterstützt.

Projektkomponenten, die einen manuellen Export erfordern

Um den Import der folgenden Projektkonfigurationselemente zu ermöglichen, müssen Sie manuell dieexportierte .zip-Datei Ihres Projekts ändern:

• Inhalt von Data User Storage

Wenn Sie in einem User File Storage-Amazon S3-Bucket gespeicherte Dateien importieren möchten,führen Sie die Schritte im Abschnitt Importieren von Inhalten aus User File Storage (p. 108) durch.

• Hosting und Streaming von Inhalten

Weitere Informationen zum Importieren von Dateien, die in einem Hosting- und Streaming-Bucketin Ihrem Originalprojekt gehostet sind, finden Sie unter Importieren von Hosting- und Streaming-Inhalt (p. 109).

• SAML-Verbund

Weitere Informationen zum Importieren von SAML-Verbundkonfigurationen für die Benutzeranmeldungaus Ihrem Originalprojekt finden Sie unter Importieren der SAML-Anmeldung für verbundeneBenutzer (p. 110).

• Cloud Logic API-Handler

Weitere Informationen zum Importieren von Cloud Logic API-Handler-Code und -Konfigurationen ausIhrem Originalprojekt finden Sie unter Importieren von API-Handlers für Cloud Logic-APIs (p. 110).

103


Note

Der Aufruf von Cloud Logic-APIs aus einem Browser heraus erfordert, dass Cross-OriginResource Sharing (CORS) für jeden API-Pfad konfiguriert ist. Weitere Informationen zurAktivierung der CORS-Konfiguration beim Importieren Ihres Projekts finden Sie unterImportieren einer Cross-Origin Resource Sharing (CORS)-Konfiguration (p. 113).

Kontenübergreifende Anmeldeinformationen

Einige Funktionen erfordern Anmeldeinformationen und Komponenten, die mit dem AWS-Konto verknüpftsind, in dem sie konfiguriert wurden. Mobile Hub-Projekte, die solche Funktionen enthalten, können nur indas Konto importiert werden, das sie exportiert hat. Zu den Funktionen mit dieser Einschränkung gehörenCloud Logic-APIs, die außerhalb des Mobile Hub-Projekts erstellt wurden, das exportiert werden soll,Anmeldeinformationen von Messaging-Providern für Push-Benachrichtigungen und Amazon SNS-Themen.

Mobile Hub-Funktion Kann von einem AWS-Konto exportiert und in einanderes importiert werden?

Benutzeranmeldung Ja

NoSQL-Datenbank Ja

Cloud Logic Verwendung von APIs, die in Ihrem Mobile Hub-Projekt erstelltwurden:

Ja

Verwendung von APIs, die in Ihr Projekt importiert wurden:

Nein (Abhilfe siehe Eine API kann nicht importiertwerden (p. 97))

User File Storage Ja

Bereitstellung von Anwendungsinhalten Ja

Konnektoren Ja

Push-Benachrichtigungen Nein (Abhilfe siehe Push-Anmeldeinformationenkönnen nicht importiert werden (p. 99))

Messaging und Analyse (Push-Benachrichtigung) Nein (Abhilfe siehe Push-Anmeldeinformationenkönnen nicht importiert werden (p. 99))

Nicht exportierte Projektkomponenten

Die folgenden Komponenten werden von der Mobile Hub-Import/Export-Funktion nicht unterstützt:

• Benutzerdefinierte Richtlinie

Wenn Sie eine Mobile Hub-Funktion aktivieren, wird eine Reihe von AWS-Services bereitgestellt. MobileHub fügt diesen Objekten Standard-Zugriffsrollen und Richtlinien hinzu. Beim Import eines Projektswerden die Standardrollen und -richtlinien übernommen.

In Ihrem ursprünglichen Projekt können Sie diese Standardwerte ändern oder ergänzen, um z. B. denZugriff auf eine Datentabelle auf „schreibgeschützt“ zu setzen. Wenn Sie Ihre Projektkonfigurationexportieren, werden solche Anpassungen nicht in den Projektexport aufgenommen. Um Ihre

104


benutzerdefinierte Richtlinie in einem importierten Projekt zu aktivieren, muss der Importeur dieseRichtlinien im importierten Projekt manuell konfigurieren. Zusätzlich zu Ihrer Projektexportdateiempfehlen wir Ihnen, sowohl Ihre Policy JSON als auch eine Schritt-für-Schritt-Anleitung für Importeurezur Verfügung zu stellen. Diese Anleitung beschreibt, wie AWS-Konsolen oder die AWS CLI verwendetwerden, um Anpassungen zu implementieren.

• Alte Cloud-Logik

Importieren und Exportieren wird für Projekte mit der alten Cloud Logic-Funktion nicht unterstützt. Einsolches Projekt ruft Lambda-Funktionen direkt auf. Die aktuelle Version von Cloud Logic führt RESTful-Aufrufe an Amazon API Gateway-APIs aus, die mit Lambda-Funktionshandlern verknüpft sind.

Mobile Hub-Projektexportformat



AWS Mobile Hub bietet die Möglichkeit, eine YAML-Datei zu exportieren, die die Konfiguration IhresProjekts enthält. Die YAML-Datei selbst kann importiert oder mit anderen Projektkomponenten, diewährend des Projektimports bereitgestellt werden, in eine .zip-Datei eingefügt werden. In diesemAbschnitt wird der Aufbau von YAML und einer typischen .zip-Datei für Mobile Hub-Projektexportebeschrieben. Weitere Informationen zur Import/Export-Funktion von Mobile Hub finden Sie unterImportieren und Exportieren von AWS Mobile Hub-Projekten (p. 101).

Themen• Struktur einer ZIP-Datei des Projektexports (p. 105)• Struktur einer YML-Datei des Projektexports (p. 106)

Struktur einer ZIP-Datei des Projektexports

Wenn Sie Export (file) ((Datei) exportieren) auswählen, generiert Mobile Hub eine entsprechend IhremProjekt benannte .zip-Datei.

Standarddateistruktur

Mobile Hub generiert außerdem die Projektkonfigurationsdatei mobile-hub-project.yml im .zip-Stammverzeichnis. Eine gültige Datei mobile-hub-project.yml in diesem Speicherort ist erforderlich,damit der Mobile Hub-Projektimport erfolgreich ausgeführt wird.

Beispielsdateistruktur

Die Dateistruktur der .zip-Datei eines exportierten Projekts, konfiguriert für die Einschließung derBereitstellung sowohl des SAML-Verbunds als auch der Cloud Logic-API-Handler, sieht folgendermaßenaus:

• /your-project-name.zip

• mobile-hub-project.yml

• saml.xml

• lambda API handler functions

• user data stored files

105

https://docs.aws.amazon.com/cli/latest/userguide/




• hosted files

Dateien in einer .zip-Datei des Projektexports können in Ordnern angeordnet werden. Die relativenPfade innerhalb des Archivs müssen in den YAML-Schlüsselwerten der Projektdefinition, die auf ihre Pfadeverweisen, übernommen werden.

Note

Das Vorhandensein von Dateien oder Ordnern in der .zip-Datei der Projektkonfiguration, mitAusnahme der im vorherigen Abschnitt beschriebenen, könnte beim Import ignoriert werden oderProbleme verursachen.

Struktur einer YML-Datei des ProjektexportsRein theoretisch sieht die Grundstruktur einer .yml-Datei von Mobile Hub-Projektexporten folgendermaßenaus:

features: FEATURE-TYPE: !com.amazonaws.mobilehub.v0.:FEATURE-TYPE components: FEATURE-NAME: !com.amazonaws.mobilehub.v0.FEATURE-TYPE attributes: ATTRIBUTE-NAME: !com.amazonaws.mobilehub.v0.ATTRIBUTE-VALUE OTHER-FEATURE-PROPERTY-TYPES: OTHER-FEATURE-PROPERTY-VALUES . . .

Die folgende YAML-Datei ist ein Beispiel für die Datei mobile-hub-project.yml, die von einemProjekt mit vielen aktivierten Mobile Hub-Funktionen exportiert wurde. Die Projektdefinition wurde ebenfallsmanuell aktualisiert, um den Import und das Hochladen von Komponenten des ursprünglichen Projekts zuermöglichen. Diese Komponenten umfassen Dateien, die im User File Storage-Bucket des ursprünglichenProjekts gespeichert sind, Dateien, die in dessen Bucket für Hosting und Streamen gehostet sind, sowieAPI-Handler-Code in dessen Lambda-Funktionen.

--- !com.amazonaws.mobilehub.v0.Projectfeatures: cloudlogic: !com.amazonaws.mobilehub.v0.CloudLogic components: api-name: !com.amazonaws.mobilehub.v0.API attributes: name: api-name requires-signin: true sdk-generation-stage-name: Development paths: /items: !com.amazonaws.mobilehub.v0.Function codeFilename: uploads/lambda-archive.zip description: "Handler for calls to resource path : /items" enableCORS: true handler: lambda.handler memorySize: "128" name: handler-name runtime: nodejs6.10 timeout: "3" "/items/{proxy+}": !com.amazonaws.mobilehub.v0.Function codeFilename: uploads/lambda-archive.zip description: "Handler for calls to resource path : /items/{proxy+}" enableCORS: true handler: lambda.handler memorySize: "128" name: handler-name runtime: nodejs6.10 timeout: "3"

106


content-delivery: !com.amazonaws.mobilehub.v0.ContentDelivery attributes: enabled: true visibility: public-global components: release: !com.amazonaws.mobilehub.v0.Bucket {} database: !com.amazonaws.mobilehub.v0.Database components: database-nosql: !com.amazonaws.mobilehub.v0.NoSQLDatabase tables: - !com.amazonaws.mobilehub.v0.NoSQLTable attributes: id: S hashKeyName: id hashKeyType: S rangeKeyName: "" rangeKeyType: "" tableName: ___DYNAMIC_PREFIX___-bbq-order tablePrivacy: public - !com.amazonaws.mobilehub.v0.NoSQLTable attributes: id: S hashKeyName: id hashKeyType: S rangeKeyName: "" rangeKeyType: "" tableName: ___DYNAMIC_PREFIX___-bbq_restaurants tablePrivacy: public - !com.amazonaws.mobilehub.v0.NoSQLTable attributes: id: S restaurant_id: S hashKeyName: restaurant_id hashKeyType: S rangeKeyName: id rangeKeyType: S tableName: ___DYNAMIC_PREFIX___-bbq_menu_item tablePrivacy: public sign-in: !com.amazonaws.mobilehub.v0.SignIn attributes: enabled: true optional-sign-in: false components: sign-in-user-pools: !com.amazonaws.mobilehub.v0.UserPoolsIdentityProvider attributes: alias-attributes: - email - phone_number mfa-configuration: ON name: userpool password-policy: !com.amazonaws.mobilehub.ConvertibleMap min-length: "8" require-lower-case: true require-numbers: true require-symbols: true require-upper-case: true user-files: !com.amazonaws.mobilehub.v0.UserFiles attributes: enabled: true user-profiles: !com.amazonaws.mobilehub.v0.UserSettings attributes: enabled: truename: myProjectregion: us-east-1uploads: - !com.amazonaws.mobilehub.v0.Upload fileName: stored-file

107


targetS3Bucket: user-file.png - !com.amazonaws.mobilehub.v0.Upload fileName: hosted-file targetS3Bucket: hosting.html - !com.amazonaws.mobilehub.v0.Upload fileName: api-handler-file.zip targetS3Bucket: deployments

Manuell exportierte Projektkomponenten



In diesem Abschnitt wird beschrieben, wie Sie Projektkomponenten manuell zu einer exportiertenProjektdefinition hinzufügen.

Themen• Importieren von User File Storage-Inhalten (p. 108)• Importieren von Hosting- und Streaming-Inhalt (p. 109)• Importieren der SAML-Anmeldung für verbundene Benutzer (p. 110)• Importieren von API-Handlers für Cloud Logic-APIs (p. 110)• Importieren einer Cross-Origin Resource Sharing (CORS)-Konfiguration (p. 113)

Importieren von User File Storage-InhaltenWenn ein Projekt, das User File Storage aktiviert, exportiert wird, werden Dateien, die in seinem AmazonS3-Bucket gespeichert sind, nicht in seine exportierte Projektdefinition aufgenommen. Sie können dieProjektdefinition manuell konfigurieren, um diese Dateien in den neuen Bucket des importierten Projektshochzuladen.

So konfigurieren Sie das Importieren und Hochladen von Projektdateien, die in einem User File Storage-Bucket gespeichert sind

1. Entpacken Sie Ihre exportierte Projekt-.zip-Datei.2. Kopieren Sie jede Datei, die Sie während des Imports hochladen möchten, und fügen Sie sie in den

entpackten Dateiordner ein.3. Fügen Sie Dateipfade zu Ihrer exportierten Projektdefinition hinzu:

a. Öffnen Sie die mobile-hub-project.yml-Datei des Exports in einem Editor.b. Erstellen Sie einen uploads:-Knoten auf Stammebene, sofern noch keiner vorhanden ist.c. Fügen Sie für jede Datei, die hochgeladen werden soll, die folgenden drei Elemente unter uploads:

hinzu.i. Der Namespace - !com.amazonaws.mobilehub.v0.Uploadii. Der Schlüssel fileName: mit dem Wert des Pfads zur Datei innerhalb der

Projektdefinitions-.zip-Datei.iii. Der Schlüssel targetS3Bucket: mit dem Wert user-files.

--- !com.amazonaws.mobilehub.v0.Projectfeatures:

108




sign-in: !com.amazonaws.mobilehub.v0.SignIn {} user-files: !com.amazonaws.mobilehub.v0.UserFiles attributes: enabled: true user-profiles: !com.amazonaws.mobilehub.v0.UserSettings attributes: enabled: truename: userfilesregion: us-east-1uploads: - !com.amazonaws.mobilehub.v0.Upload fileName: {example1.png} targetS3Bucket: user-files - !com.amazonaws.mobilehub.v0.Upload fileName: {example2.xml} targetS3Bucket: user-files. . .

4. Komprimieren Sie die Dateien innerhalb der entpackten Projektdefinitionsdatei erneut (nicht den Ordner,der diese Dateien enthält, da dadurch ein Pfadfehler verursacht würde).

Importieren von Hosting- und Streaming-InhaltWenn ein Projekt, das Hosting und Streaming ermöglicht, exportiert wird, werden Dateien, die in seinemAmazon S3-Bucket gespeichert sind, nicht in die exportierte Projektdefinition aufgenommen. Sie könnendie Projektdefinition manuell konfigurieren, um diese Dateien in den neuen Bucket des importierten Projektshochzuladen.

So konfigurieren Sie den Import- und Uploadvorgang von Projektdateien, die in einem Bucket für dasHosting und Streaming gespeichert sind

1. Entpacken Sie Ihre exportierte Projekt-.zip-Datei.2. Kopieren Sie jede Datei, die Sie während des Imports hochladen möchten, und fügen Sie sie in den

entpackten Dateiordner ein.3. Fügen Sie Dateipfade zu Ihrer exportierten Projektdefinition hinzu:

a. Öffnen Sie die mobile-hub-project.yml-Datei des Exports in einem Editor.b. Erstellen Sie einen uploads:-Knoten auf Stammebene, sofern noch keiner vorhanden ist.c. Fügen Sie für jede Datei, die hochgeladen werden soll, die folgenden drei Elemente unter uploads:


Projektdefinitions-.zip-Datei.iii. Der Schlüssel targetS3Bucket: mit dem Wert hosting.

--- !com.amazonaws.mobilehub.v0.Projectfeatures: content-delivery: !com.amazonaws.mobilehub.v0.ContentDelivery attributes: enabled: true visibility: public-global components: release: !com.amazonaws.mobilehub.v0.Bucket {}

. . .

uploads: - !com.amazonaws.mobilehub.v0.Upload fileName: {example1.html} targetS3Bucket: hosting

109


- !com.amazonaws.mobilehub.v0.Upload fileName: {example2.js} targetS3Bucket: hosting. . .


Importieren der SAML-Anmeldung für verbundene BenutzerDie Konfiguration des SAML-Verbunds für die Mobile Hub-Benutzeranmeldung erfordert die Bereitstellungder SAML XML-Konfiguration (saml.xml) des Identitätsanbieters, den Sie verbinden. Die SAML XML-Konfiguration ist nicht in der .zip-Datei enthalten, die von Mobile Hub exportiert wird.

So konfigurieren Sie ein exportiertes Projekt, damit es den SAML Verbund des Originalprojekts bereitstellt,wenn es importiert wird

1. Entpacken Sie Ihre exportierte Projekt-.zip-Datei.2. Kopieren Sie die saml.xml-Datei Ihres Identitätsanbieters in den Stammordner der entpackten .zip-

Datei.3. Komprimieren Sie die Dateien innerhalb der entpackten Projektdefinitionsdatei erneut (nicht den Ordner,

der diese Dateien enthält, da dadurch ein Pfadfehler verursacht würde).

Importieren von API-Handlers für Cloud Logic-APIsDie Mobile Hub-Cloud Logic-Funktion paart eine RESTful-API-Oberfläche (API Gateway) mit serverlosenAPI-Handler-Funktionen (Lambda). Während Mobile Hub das Exportieren und Importieren der Definitionenvon API- und Handler-Objekten unterstützt, die Cloud Logic konfiguriert, wird der API-Handler-Funktionscode nicht exportiert.

Mit Mobile Hub können Sie Ihre Projektexport-.zip-Datei manuell konfigurieren, um Ihren API-Handler-Funktionscode als Teil des Projektimports bereitzustellen, wenn folgende Bedingungen erfüllt sind:

• Ihr API-Handler greift nur auf DynamoDB-Tabellen zu. Der Import von API-Handlers, die auf andereAWS-Services, wie Amazon S3 zugreifen, wird derzeit nicht unterstützt.

• Ihr Handler-Code berücksichtigt die Verwendung von Lambda-Umgebungsvariablen, um sich auf dieseDynamoDB-Tabellen zu beziehen.

Wenn Mobile Hub API-Handler-Code importiert, werden Umgebungsvariablen verwendet, umDatenoperationen den neuen Tabellen zuzuordnen, die vom Import erstellt wurden. Sie könnenden Schlüsselnamen der Umgebungsvariablen in der Definitions-YAML des Projekts definieren, umKonstantennamen abzustimmen, die Sie im Lambda-API-Handler-Funktionscode des Projekts definieren.Das folgende Beispiel zeigt eine Lambda-Funktionskonstante, die mit einer Umgebungsvariableabgeglichen wird.

const YOUR-FUNCTION-CONSTANT-NAME = process.env.KEY-NAME-DEFINED-IN-YAML;";

// exampleconst MENU_TABLE_NAME = process.env.MENU_TABLE_NAME;

In den Schritten, die auf diese Hinweise folgen, wird beschrieben, wie Sie Ihre Umgebungsvariablen inder Projektdefinitions-YAML definieren.

Note

Alternativ kann das Projekt-ID-Präfix MOBILE_HUB_DYNAMIC_PREFIX verwendet werden,das von Mobile Hub erzeugt wird. Mobile Hub konfiguriert seinen Wert als eindeutige

110

https://docs.aws.amazon.com/lambda/latest/dg/tutorial-env_cli.html


Kennung für das importierte Projekt. Wenn Sie einen gültigen Tabellennamen an das Präfixin Ihrem Funktionscode anhängen, erstellt er einen gültigen Identifier für die Tabelle imimportierten Projekt. Das folgende Beispiel zeigt eine Lambda-Funktionskonstante, die mit einerUmgebungsvariable abgeglichen wird.

const YOUR-FUNCTION-CONSTANT-NAME = process.env.MOBILE_HUB_DYNAMIC_PREFIX + "-YOUR-TABLE-NAME";

// exampleconst MENU_TABLE_NAME = process.env.MOBILE_HUB_DYNAMIC_PREFIX + "-bbq-menu";

Diese Methode erfordert keine zusätzliche manuelle Konfiguration der Projektdefinition-YAML.

Die AWS Mobile React-Beispielanwendung bietet ein umfassendes Beispiel für die Verwendung vonUmgebungsvariablen, um über eine API und ihren Handler auf Datentabellen zuzugreifen. Führen Sie diefolgenden Schritte für jeden API-Handler durch, dessen Code Sie importieren möchten. EntsprechendeBeispiele aus der Beispielanwendung werden gegeben.

So aktivieren Sie den Import von |LAM|-Handler-Funktionen für Ihre exportierte Cloud Logic-API

1. Entpacken Sie Ihre exportierte Projekt-.zip-Datei.2. Kopieren Sie Ihre Lambda-Funktion(en) in die entpackte Datei.

a. Navigieren Sie zur Amazon S3-Konsole und suchen Sie nach Ihrem Mobile Hub-Projektnamen.b. Wählen Sie den Bucket mit dem Namen, der -deployments- enthält, und wählen Sie dann den

uploads-Ordner.c. Kopieren und speichern Sie die Namen der Lambda-Funktionsdateien im Ordner, um sie in den

nächsten Schritten zu verwenden.d. Kopieren Sie die Lambda-Funktionsdateien im Ordner in Ihre entpackte exportierte Projektdatei.

3. Fügen Sie Dateipfade zu Ihrer exportierten Projektdefinition hinzu.a. Öffnen Sie die mobile-hub-project.yml-Datei des Exports in einem Editor.b. Erstellen Sie einen uploads:-Knoten auf Stammebene, sofern noch keiner vorhanden ist.c. Fügen Sie für jede Datei, die hochgeladen werden soll, die folgenden drei Elemente unter uploads:


Projektdefinitions-.zip-Datei.iii. Der Schlüssel targetS3Bucket: mit dem Wert deployments.

d. Wenn nicht bereits in jedem Cloud Logic-. . . paths: items-Knoten vorhanden, erstellen Sieeinen codeFilename:-Schlüssel mit dem Wert des Pfads der Lambda-Funktionscodedatei fürdiesen Handler.

Note

Der Pfad in diesem Fall ist relativ zum Stamm des -deployments-Amazon S3-Buckets,den Mobile Hub für Cloud Logic bereitgestellt hat. In der Regel platziert Mobile Hub dieseDateien in einem /uploads-Ordner.Wenn kein codeFilename angegeben ist, stellt Mobile Hub einen Standard-Handler bereit,der empfangene Anfragen wiedergibt.

e. Fügen Sie Umgebungsvariablen zu Ihrer exportierten Projektdefinition hinzu.

Fügen Sie für jeden Cloud Logic-. . . paths: items-Knoten, der einen Handler beschreibt,der mit einer DynamoDB-Tabelle interagiert, einen environment:-Knoten mit untergeordnetenMitgliedern hinzu, die zusammengestellt werden, indem der Name einer Umgebungsvariable mitder Zeichenfolge __DYNAMIC_PREFIX__ und dem zugehörigen Tabellennamen verkettet wird.

111




Der Variablenname sollte der zugehörigen Variable in Ihrem Lambda-API-Handler-Funktionscodezugeordnet werden.

--- !com.amazonaws.mobilehub.v0.Projectfeatures: cloudlogic: !com.amazonaws.mobilehub.v0.CloudLogic components: api-name: !com.amazonaws.mobilehub.v0.API attributes: name: api-name requires-signin: true sdk-generation-stage-name: Development paths: /items: !com.amazonaws.mobilehub.v0.Function codeFilename: {uploads/lambda-archive.zip} description: "Handler for calls to resource path : /items" enableCORS: true handler: lambda.handler memorySize: "128" name: handler-name runtime: nodejs6.10 timeout: "3" environment: {MENU_TABLE_NAME}: ___DYNAMIC_PREFIX___{-bbq_menu_item} {ORDERS_TABLE_NAME}: ___DYNAMIC_PREFIX___{-bbq_orders} {RESTAURANTS_TABLE_NAME}: ___DYNAMIC_PREFIX___-{bbq_restaurants} "/items/{proxy+}": !com.amazonaws.mobilehub.v0.Function codeFilename: {uploads/lambda-archive.zip} description: "Handler for calls to resource path : /items/{proxy+}" enableCORS: true handler: lambda.handler memorySize: "128" name: handler-name runtime: nodejs6.10 timeout: "3" environment: {MENU_TABLE_NAME}: ___DYNAMIC_PREFIX___{-bbq_menu_item} {ORDERS_TABLE_NAME}: ___DYNAMIC_PREFIX___{-bbq_orders} {RESTAURANTS_TABLE_NAME}: ___DYNAMIC_PREFIX___-{bbq_restaurants}. . .

uploads: - !com.amazonaws.mobilehub.v0.Upload fileName: {lambda-archive.zip} targetS3Bucket: deployments - !com.amazonaws.mobilehub.v0.Upload fileName: {lambda.jar} targetS3Bucket: deployments. . .

4. Speichern Sie die .yml-Datei und komprimieren Sie die Dateien innerhalb der entpacktenProjektdefinitionsdatei erneut (nicht den Ordner, der diese Dateien enthält, da dadurch ein Pfadfehlerverursacht würde).

5. Testen Sie Ihre überarbeitete Projektexportdefinition, indem Sie sie über die Mobile Hub-Importieren. Siekönnen Ihre Umgebungsvariablen über die Lambda-Konsole überprüfen.

Note

Standardmäßig konfiguriert die NoSQL-Datenbankfunktion von Mobile Hub die Berechtigungeneiner Tabelle, um Lese- und Schreibzugriff für Lambda-Funktionen zu gewähren. Diese Art vonbenutzerdefinierter IAM-Richtlinienkonfiguration, die für die Änderung der Tabellenberechtigungenerforderlich ist, ist nicht im Export eines Projekts enthalten. Ein Importer eines Projekts, das von

112

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchAmazon CloudFront – Sicherheit

einer benutzerdefinierten Richtlinie abhängt, benötigt ausreichend Informationen, um die Richtlinieerneut zu erstellen, sobald das Projekt importiert wurde. Für einen solchen Fall empfehlen wir,sowohl die Richtlinien-JSON als auch Schritt-für-Schritt-Anweisungen (console oder AWS CLI)dazu, wie und wo sie angefügt werden soll, bereitzustellen. Weitere Informationen zu diesenSchritt finden Sie unter Authentifizierung und Zugriffskontrolle für Amazon DynamoDB.

Importieren einer Cross-Origin Resource Sharing (CORS)-KonfigurationStandardmäßig verhindert die AWS-Sicherheitsinfrastruktur Aufrufe einer API Gateway-API von einemBrowser. Durch das Konfigurieren von CORS für jeden Pfad Ihrer API können API-Aufrufe sicher überdas Web getätigt werden. Die CORS-Konfiguration ist nicht im Mobile Hub-Projektexport enthalten.Die folgenden Schritte beschreiben, wie Sie den Import der CORS-Konfiguration manuell in IhreProjektexportdatei einfügen.

So schließen Sie die CORS-Konfiguration für Ihre |ABP|-API-Pfade ein

1. Entpacken Sie Ihre exportierte Projektdefinitions-.zip-Datei.2. Öffnen Sie die mobile-hub-project.yml-Datei des Exports in einem Editor.3. Fügen Sie für jeden API-Pfad einen Schlüssel namens enableCORS mit dem Wert true unter ...

paths: "/items/. . .": !com.amazonaws.mobilehub.v0.Function hinzu, wie im folgendenFragment gezeigt.

--- !com.amazonaws.mobilehub.v0.Project features: cloudlogic: !com.amazonaws.mobilehub.v0.CloudLogic components: ReactSample: !com.amazonaws.mobilehub.v0.API attributes: name: ReactSample requires-signin: false paths: "/items/{proxy+}": !com.amazonaws.mobilehub.v0.Function name: FirstHandler handler: lambda.handler enableCORS: true runtime: nodejs6.10 . . .


Amazon CloudFront-Sicherheitsüberlegungen fürMobile Hub-Benutzer



Wenn Sie die Funktion Hosting und Streaming (p. 65) in AWS Mobile Hub aktivieren, wird eine AmazonCloudFront-Verteilung in Ihrem Konto erstellt. Die Verteilung sorgt für die Zwischenspeicherung vonWebkomponenten innerhalb eines verknüpften Amazon S3-Buckets in einem globalen Netzwerk ausAmazon-Edge-Servern. Dadurch erhalten Ihre Kunden schnellen lokalen Zugriff auf die Webkomponenten.

113

https://docs.aws.amazon.com/lambda/latest/dg/authentication-and-access-control.html





AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchAmazon CloudFront – Sicherheit

In diesem Thema werden die wichtigsten sicherheitsrelevanten CloudFront-Funktionen beschrieben, dieSie für Ihre Verteilung nutzen können. Entsprechende Informationen zum Quell-Bucket finden Sie unter s3-security.

ZugriffsverwaltungDurch Hosting und Streaming werden Komponenten in einer Verteilung öffentlich bereitgestellt. Währenddies der normalen Sicherheitsrichtlinie für internetbasierte Ressourcen entspricht, sollten Sie in Erwägungziehen, den Zugriff auf Komponenten zu beschränken, wenn dies nicht der Fall ist. Was die Sicherheitbetrifft, hat sich eine Methode bewährt, die auf minimalen Berechtigungen beruht und den Zugriffauf Ressourcen so weit wie möglich einschränkt. Sie können ressourcenbasierte Richtlinien wie dieVerteilungsrichtlinie oder Zugriffskontrolllisten (ACL, Access Control List) ändern, um den Zugriff nureinigen Benutzern oder Benutzergruppen zu erteilen.

Zum Schutz des Zugriffs auf AWS-Ressourcen, die mit einer Hosting- und Streaming-Web-App verknüpftsind, wie z. B. Buckets und Datenbanktabellen, wird empfohlen, nur authentifizierten Benutzern den Zugriffzu erteilen. Sie können diese Einschränkung in Ihrem Mobile Hub-Projekt hinzufügen, indem Sie dieFunktion Benutzeranmeldung (p. 72) mit der Option für eine erforderliche Anmeldung aktivieren.

Weitere Informationen finden Sie im Kapitel zu Authentifizierung und Zugriffskontrolle für CloudFront imAmazon CloudFront-Entwicklerhandbuch.

Fordern des HTTPS-ProtokollsCloudFront unterstützt die Verwendung des HTTPS-Protokolls für die Verschlüsselung der Kommunikationmit einer Verteilung. Diese sehr empfehlenswerte Praxis schützt sowohl den Benutzer als auchden Service. Mit CloudFront können Sie festlegen, dass HTTPS zwischen den Kunden und IhrenVerteilungsendpunkten und CloudFront zwischen den Zwischenspeichern Ihrer Verteilung und dem Quell-Bucket, aus dem die Komponenten stammen, erforderlich ist. Außerdem werden die globale Umleitungvon HTTP-Datenverkehr an HTTPS, die Verwendung von HTTPS für benutzerdefinierte Domänen sowieandere Optionen unterstützt.

Weitere Informationen finden Sie unter Verwenden von HTTPS mit CloudFront im Amazon CloudFront-Entwicklerhandbuch.

Schützen privater InhalteCloudFront unterstützt eine Reihe von Methoden zum Schutz privater Inhalte in einem Verteilungs-Cache.Dazu gehören signierte Cookies und signierte URLs, um den Zugriff auf authentifizierte und autorisierteBenutzer zu beschränken.

Eine bewährte Methode ist, Techniken wie diese für die Verbindung zwischen dem Benutzer und demVerteilungsendpunkt und zwischen der Verteilung und dem Amazon S3-Inhaltsquell-Bucket einzusetzen.

Weitere Informationen finden Sie im Abschnitt Verarbeiten privater Inhalte über CloudFront im AmazonCloudFront-Entwicklerhandbuch.

Protokollieren des Zugriffs auf die VerteilungMithilfe der Verteilungsprotokollierung erfahren Sie mehr über die Benutzer Ihrer App, erfüllen diePrüfanforderungen Ihrer Organisation und machen sich mit den CloudFront-Kosten vertraut. JederZugriffsprotokolldatensatz enthält Details über eine Zugriffsanforderung, z. B. Auftraggeber, Name derVerteilung, Anforderungszeit, Anforderungsaktion, Antwortstatus und Fehlercode, falls vorhanden. Siekönnen Protokolle in einem Amazon S3-Bucket speichern. Um Ihre Kosten zu senken, können SieProtokolle, die Sie nicht mehr benötigen, löschen oder Sie können die Protokollierung aussetzen.

Weitere Informationen finden Sie unter Zugreifen auf Protokolle für CloudFront im Amazon CloudFront-Entwicklerhandbuch.

114

https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/auth-and-access-control.html

https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/using-https.html

https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/PrivateContent.html

https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/AccessLogs.html

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchAmazon S3-Sicherheit

Amazon S3-Sicherheitsüberlegungen für Mobile Hub-Benutzer



Wenn Sie die Funktionen Mobile Hub User File Storage oder Hosting und Streaming aktivieren, wird einAmazon S3-Bucket in Ihrem Konto erstellt. In diesem Thema werden die wichtigsten sicherheitsrelevantenAmazon S3-Funktionen beschrieben, die Sie für diesen Bucket nutzen können. Die Funktion für Hostingund Streaming konfiguriert außerdem eine CloudFront-Verteilung, die die Komponenten zwischenspeichert,die in dem Bucket, der erstellt wird, gespeichert sind. Entsprechende Informationen zur Verteilung findenSie unter "cloudfront-security".

ZugriffsverwaltungStandardmäßig ist der Zugriff auf Amazon S3-Buckets und zugehörige Objekte privat: Nur derRessourceninhaber kann auf einen Bucket oder die darin enthaltenen Komponenten zugreifen. DerAdministrator eines Buckets kann Zugriff gewähren, der zum jeweiligen Entwurf passt, indem erressourcenbasierte Richtlinien, wie etwa eine Bucket-Richtlinie, oder Zugriffskontrolllisten (ACLs) anfügt,um Benutzern oder Benutzergruppen Zugriff zu erteilen.

Die Amazon S3-Konfiguration, die von der AWS Mobile Hub-Funktion Hosting und Streaming (p. 65)bereitgestellt wird, ist ein Beispiel für das Festlegen einer Bucket-Richtlinie, um allen Benutzern Zugriffzu gewähren. Diese vordefinierte Zugriffsrichtlinie ist sinnvoll im Kontext des öffentlichen Hostings einerWeb-App über diese Funktion. Entwicklern wird empfohlen, wenn es den Anwendungsentwurfskriterienentspricht, auch die Funktion Benutzeranmeldung (p. 72) hinzuzufügen, damit nur authentifizierteBenutzer Zugriff auf die AWS-Ressourcen einer App, wie etwa Buckets und Datenbank, haben.

Weitere Informationen finden Sie unter Übersicht über die Verwaltung von Zugriffsberechtigungen für IhreAmazon S3-Ressourcen im Amazon S3-Entwicklerhandbuch.

Object Lifecycle ManagementSie können die Objektlebenszyklusverwaltung verwenden, damit Amazon S3 Aktionen für Dateien (diein Amazon S3 auch als Objekte bezeichnet werden) in einem Bucket basierend auf bestimmten Kriteriendurchführt. Wenn beispielsweise eine bestimmte Zeitdauer vergangen ist, seitdem ein Benutzer dermobilen App eine Datei in den Bucket hochgeladen hat, könnten Sie diese Datei dauerhaft löschen odersie zu Amazon S3 Glacier verschieben. Sie sollten dies tun, um die Menge der Daten in den Dateien zureduzieren, auf die andere Benutzer der mobilen App potenziell zugreifen können. Außerdem können SieIhre Kosten senken, indem Sie Dateien löschen oder archivieren, von denen Sie wissen, dass sie vonIhnen oder Benutzern der mobilen App nicht mehr benötigt werden.

Weitere Informationen finden Sie unter Objektlebenszyklusverwaltung im Amazon S3-Entwicklerhandbuch.

ObjektverschlüsselungObjektverschlüsselung hilft, den Schutz der Daten in den Dateien zu verstärken, während sie in einenoder von einem Bucket übertragen werden und auch während sie sich in einem Bucket befinden. Siekönnen Amazon S3 verwenden, um die Dateien zu verschlüsseln, oder Sie können die Dateien selbst

115



https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/s3-access-control.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lifecycle-mgmt.html

AWS Mobile Hub – Entwicklerhandbuch EntwicklerhandbuchAmazon S3-Sicherheit

verschlüsseln. Dateien können mit einem Amazon S3-verwalteten Verschlüsselungsschlüssel, einemvon AWS Key Management Service (AWS KMS) verwalteten Schlüssel oder Ihrem eigenen Schlüsselverschlüsselt werden.

Weitere Informationen finden Sie unter Daten durch Verschlüsselung schützen im Amazon S3-Entwicklerhandbuch.

Objekt-VersioningMit Objekt-Versioning können Sie Daten in Dateien nach unbeabsichtigten Aktionen von Benutzern dermobilen App oder Fehlern in der mobilen App einfacher wiederherstellen. Versioning ermöglicht Ihnen,mehrere Versionen derselben Datei in einem Bucket zu speichern. Sie können auf jede Version einzelnüber ihren zugehörigen Dateinamen und die Versions-ID zugreifen. Um Ihre Kosten zu senken, können Sieältere Versionen, die Sie nicht mehr benötigen, löschen oder archivieren oder Sie können das Versioningaussetzen.

Weitere Informationen dazu finden Sie unter Verwenden von Versioning im Amazon S3-Entwicklerhandbuch.

Bucket-ProtokollierungMithilfe der Bucket-Protokollierung erhalten Sie weitere Informationen über die Benutzer Ihrer App, könnendie Prüfanforderungen Ihrer Organisation erfüllen und Ihre Amazon S3-Kosten besser verstehen. JederZugriffsprotokolldatensatz enthält Details über eine Zugriffsanforderung, z. B. Auftraggeber, Bucket-Name, Anforderungszeit, Anforderungsaktion, Antwortstatus und Fehlercode, falls vorhanden. Sie könnenProtokolle in demselben Bucket oder in einem anderen speichern. Um Ihre Kosten zu senken, können SieProtokolle, die Sie nicht mehr benötigen, löschen oder Sie können die Protokollierung aussetzen.

Weitere Informationen finden Sie im Thema zum Verwalten der Protokollierung von Buckets im AmazonS3-Benutzerhandbuch.

116

https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingEncryption.html

https://docs.aws.amazon.com/AmazonS3/latest/dev/Versioning.html

https://docs.aws.amazon.com/AmazonS3/latest/user-guide/ManagingBucketLogging.html

Documents

AWS Mobile Hub – Entwicklerhandbuch - Entwicklerhandbuch · 2020. 7. 16. · AWS Mobile Hub – Entwicklerhandbuch Entwicklerhandbuch Entwicklung mobiler und Web-Apps Das Amplify