AWS CodeStar - Benutzerhandbuch · AWS CodeStar Benutzerhandbuch Schritt 1: Erstellen eines AWS-Kontos Einrichten von AWS CodeStar Bevor Sie AWS CodeStar verwenden können, müssen

AWS CodeStarBenutzerhandbuch

AWS CodeStar Benutzerhandbuch

AWS CodeStar: BenutzerhandbuchCopyright © 2019 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

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 ContentsWas ist AWS CodeStar? ..................................................................................................................... 1

Wofür kann ich AWS CodeStar verwenden;? .................................................................................. 1Erste Schritte mit AWS CodeStar .................................................................................................. 1

Einrichten .......................................................................................................................................... 3Schritt 1: Erstellen eines AWS-Kontos ........................................................................................... 3Schritt 2: Erstellen der AWS CodeStar-Servicerolle .......................................................................... 3Schritt 3: Konfigurieren der IAM-Berechtigungen für Benutzer ............................................................ 3

Konfigurieren von Berechtigungen für IAM-Benutzer ................................................................. 4Berechtigungen für verbundene Benutzer konfigurieren ............................................................ 4

Schritt 4:Erstellen eines Amazon EC2-Schlüsselpaars für AWS CodeStar-Projekte ................................ 5Schritt 5: Öffnen der AWS CodeStar-Konsole ................................................................................. 5Nächste Schritte ......................................................................................................................... 5

Erste Schritte mit AWS CodeStar .......................................................................................................... 6Schritt 1: Erstellen eines AWS CodeStar-Projekts ............................................................................ 6Schritt 2: Hinzufügen von Anzeigeinformationen für Ihr AWS CodeStar-Benutzerprofil ............................ 9Schritt 3: Anzeigen Ihres Projekts ................................................................................................. 9Schritt 4: Anpassen der Kachel „Team Wiki” und des Projekt-Dashboards .......................................... 10Schritt 5: Durchführen des Commits für eine Änderung ................................................................... 11Schritt 6: Hinzufügen von weiteren Teammitgliedern ....................................................................... 15Schritt 7: Bereinigen .................................................................................................................. 18Schritt 8: Machen Sie Ihr Projekt für eine Produktionsumgebung bereit. ............................................. 19Nächste Schritte ....................................................................................................................... 19Tutorial für serverlose Projekte ................................................................................................... 19

Übersicht ......................................................................................................................... 20Schritt 1: Erstellen des Projekts ........................................................................................... 20Schritt 2: Entdecken Sie die Projekt-Ressourcen .................................................................... 21Schritt 3: Testen des Webservice ........................................................................................ 24Schritt 4: Einrichten Ihrer lokalen Workstation zur Bearbeitung des Projektcodes ......................... 25Schritt 5: Dem Webservice Logik hinzufügen ......................................................................... 26Schritt 6: Testen des erweiterten Webservice ........................................................................ 27Schritt 7: Hinzufügen eines Einheitentests für den Webservice ................................................. 28Schritt 8: Anzeigen der Ergebnisse des Einheitentests ............................................................ 30Schritt 9: Bereinigen .......................................................................................................... 30Nächste Schritte ............................................................................................................... 31

AWS CLI-Projekt-Tutorial ........................................................................................................... 31Schritt 1: Laden Sie den exemplarischen Quellcode herunter und überprüfen Sie ihn. ................... 32Schritt 2: Laden Sie die Beispiel-Toolchain-Vorlage herunter .................................................... 32Schritt 3: Testen Sie Ihre Toolchain-Vorlage in AWS CloudFormation ........................................ 33Schritt 4: Laden Sie Ihren Quellcode und Ihre Toolchain-Vorlage hoch ...................................... 34Schritt 5: Erstellen eines Projekts in AWS CodeStar ............................................................... 35

Alexa Skill-Projekt – Tutorial ....................................................................................................... 36Voraussetzungen .............................................................................................................. 37Schritt 1: Erstellen des Projekts und Verbinden Ihres Amazon-Entwicklerkontos .......................... 37Schritt 2: Testen des Skills im Alexa Simulator ...................................................................... 38Schritt 3: Entdecken der Projekt-Ressourcen ......................................................................... 39Schritt 4: Ändern der Antwort Ihres Skills .............................................................................. 39Schritt 5: Einrichten der lokalen Arbeitsstation, um eine Verbindung zu Ihrem Projekt-Repositoryherzustellen ...................................................................................................................... 39Nächste Schritte ............................................................................................................... 40

Projektvorlagen ................................................................................................................................. 41AWS CodeStar Projektdateien und Ressourcen ............................................................................. 41Fangen Sie an: Wählen Sie eine Projektvorlage aus ...................................................................... 42

Wählen Sie einen Vorlagen-Anwendungstyp aus ................................................................... 42Wählen Sie eine Programmiersprachenvorlage ...................................................................... 43

iii


Wählen Sie eine Compute-Plattform-Vorlage ......................................................................... 43Wie Sie Änderungen an Ihrem AWS CodeStar-Projekt vornehmen können ......................................... 44

Ändern des Anwendungsquellcodes und Push von Änderungen ............................................... 44Ändern von Anwendungsressourcen mit der Datei Template.yml .............................................. 44...................................................................................................................................... 45

Bewährte Methoden für AWS CodeStar ................................................................................................ 46Bewährte Methoden für die Sicherheit für AWS CodeStar-Ressourcen .............................................. 46Bewährte Methoden zum Festlegen von Versionen für Abhängigkeiten .............................................. 46Bewährte Methoden für die Überwachung und Protokollierung für AWS CodeStar-Ressourcen .............. 46

Arbeiten mit Projekten ....................................................................................................................... 48Erstellen eines Projekts ............................................................................................................. 49

Erstellen eines Projekts in AWS CodeStar (Konsole) .............................................................. 49Erstellen eines Projekts in AWS CodeStar (AWS CLI) ............................................................ 51

Verwenden einer IDE für AWS CodeStar ...................................................................................... 56AWS Cloud9 und AWS CodeStar ........................................................................................ 57Verwenden von Eclipse für AWS CodeStar ........................................................................... 62Visual Studio und AWS CodeStar ....................................................................................... 66

Anpassen eines Projekt-Dashboards ............................................................................................ 67Hinzufügen, Entfernen oder Verschieben von Kacheln in Ihrem Dashboard ................................ 67Hinzufügen einer Projekterweiterung zu Ihrem Dashboard ....................................................... 67Anpassen der Team-Wiki-Kachel ......................................................................................... 68

Ändern von Projekt-Ressourcen .................................................................................................. 68Unterstützte Ressourcenänderungen .................................................................................... 68Hinzufügen einer Stufe zu AWS CodePipeline ....................................................................... 70Ändern der AWS Elastic Beanstalk-Umgebungseinstellungen ................................................... 70Ändern einer AWS Lambda-Funktion in Quellcode ................................................................. 70Tracing für ein Projekt aktivieren ......................................................................................... 71Hinzufügen einer Ressource zu einem Projekt ....................................................................... 73Hinzufügen einer IAM-Rolle zu einem Projekt ........................................................................ 77Fügen Sie eine Prod-Stufe und einen Endpunkt zu einem Projekt hinzu. .................................... 78Sicheres Verwenden von SSM-Parametern in einem AWS CodeStar-Projekt .............................. 84

Shift Traffic für ein AWS Lambda-Projekt ...................................................................................... 85Übergang Ihres AWS CodeStar-Projekts in die Produktion .............................................................. 90

Erstellen eines GitHub-Repositorys ...................................................................................... 91Arbeiten mit Projekt-Tags ........................................................................................................... 92

Einem Projekt ein Tag hinzufügen ....................................................................................... 92Ein Tag von einem Projekt entfernen ................................................................................... 92Abrufen einer Tag-Liste für ein Projekt ................................................................................. 92

Löschen eines Projekts .............................................................................................................. 92Löschen eines Projekts in AWS CodeStar (Konsole) .............................................................. 93Löschen eines Projekts in AWS CodeStar (AWS CLI) ............................................................. 94

Arbeiten mit Teams ........................................................................................................................... 95Hinzufügen von Teammitgliedern zu einem Projekt ........................................................................ 96

Ein Teammitglied hinzufügen (Konsole) ................................................................................ 97Hinzufügen und Anzeigen von Teammitgliedern (AWS CLI) ................................................... 100

Teamberechtigungen verwalten ................................................................................................. 100Teamberechtigungen verwalten (Konsole) ........................................................................... 101Teamberechtigungen verwalten (AWS CLI) ......................................................................... 102

Entfernen von Teammitgliedern aus einem Projekt ....................................................................... 102Entfernen von Teammitgliedern (Konsole) ........................................................................... 103Entfernen von Teammitgliedern (AWS CLI) ......................................................................... 103

Arbeiten mit Ihrem AWS CodeStar-Benutzerprofil ................................................................................. 105Verwalten von Anzeigeinformationen .......................................................................................... 105

Verwalten Ihres Benutzerprofils (Konsole) ........................................................................... 106Benutzerprofile verwalten (AWS CLI) .................................................................................. 106

Hinzufügen eines öffentlichen Schlüssels zu Ihrem Benutzerprofil ................................................... 108So verwalten Sie Ihren öffentlichen Schlüssel (Konsole) ........................................................ 109

iv


Verwalten Ihres öffentlichen Schlüssels (AWS CLI) ............................................................... 110Herstellen einer Verbindung zur Amazon EC2-Instance mit Ihrem privaten Schlüssel .................. 110

Zugriffsberechtigungen – Referenz ..................................................................................................... 112AWS CodeStar-Projektebenenrichtlinien und -berechtigungen ........................................................ 113

IAM-Richtlinien für Teammitglieder ..................................................................................... 113IAM-Richtlinien für Auftragnehmerrollen .............................................................................. 114IAM-Richtlinie für die Ausführungsrolle ............................................................................... 115IAM-Berechtigungsgrenze ................................................................................................. 115Vorhandenen Projekten eine IAM-Berechtigungsgrenze hinzufügen ......................................... 116

Richtlinie und Berechtigungen für die AWS CodeStar Service-Rolle ................................................. 117Aktions- und Ressourcensyntax ................................................................................................. 118

Bestimmen des Geltungsbereichs von Ressourcen in AWS CodeStar ...................................... 119Projekte ......................................................................................................................... 119Ressourcen .................................................................................................................... 119Teams ........................................................................................................................... 120Benutzer ........................................................................................................................ 120

Beispiele für AWS CodeStar-Richtlinien ...................................................................................... 121AWS-verwaltete Richtlinien ............................................................................................... 121Vom Kunden verwaltete Richtlinien .................................................................................... 124Eingebundene Richtlinien ................................................................................................. 128

IAM-Benutzerzugriff auf AWS CodeStar ...................................................................................... 137Einen IAM-Benutzer zu Ihrem AWS CodeStar-Projekt hinzufügen ........................................... 137Entfernen eines IAM-Benutzers aus Ihrem AWS CodeStar;-Projekt. ......................................... 137Anfügen einer Inline-Richtlinie an einen IAM-Benutzer ........................................................... 137

Zugriff für verbundene Benutzer auf AWS CodeStar ..................................................................... 138Anfügen der verwalteten Richtlinie AWSCodeStarFullAccess an die Rolle des verbundenenBenutzers. ...................................................................................................................... 139Fügen Sie die verwaltete AWS CodeStar Betrachter/Beitragender/Eigentümer-Richtlinie IhresProjekts der Rolle des verbundenen Benutzers hinzu. ........................................................... 139Trennen einer von AWS CodeStar verwalteten Richtlinie von der Rolle des verbundenenBenutzers. ...................................................................................................................... 140Anfügen einer von AWS Cloud9 verwalteten Richtlinie an die Rolle des verbundenen Benutzers. .. 140Trennen einer von AWS Cloud9 verwalteten Richtlinie von der Rolle des verbundenen Benutzers. 141

Protokollieren von AWS CodeStar-API-Aufrufen mit AWS CloudTrail ....................................................... 142AWS CodeStar-Informationen in CloudTrail ................................................................................. 142Grundlagen zu AWS CodeStar-Protokolldateieinträgen .................................................................. 143

Limits ............................................................................................................................................ 145AWS CodeStar-Fehlerbehebung ........................................................................................................ 147

Fehler beim Erstellen eines Projekts: Ein Projekt wurde nicht erstellt. .............................................. 147Projekterstellung: Ich sehe einen Fehler, wenn ich versuche, die Amazon EC2-Konfiguration beimErstellen eines Projekts zu bearbeiten. ....................................................................................... 148Projektlöschung: Ein AWS CodeStar-Projekt wurde gelöscht, es sind jedoch weiterhin Ressourcenvorhanden. ............................................................................................................................. 148Teammanagement-Fehler: Ein IAM-Benutzer konnte nicht zu einem Team in einem AWS CodeStar-Projekt hinzugefügt werden. ...................................................................................................... 150Zugrifffehler: Ein verbundener Benutzer hat keinen Zugriff auf ein AWS CodeStar-Projekt ................... 150Zugrifffehler: Ein verbundener Benutzer kann auf eine AWS Cloud9-Umgebung nicht zugreifen oderdiese erstellen. ....................................................................................................................... 150Zugrifffehler: Ein verbundener Benutzer kann ein AWS CodeStar-Projekt erstellen, aber keineProjektressourcen anzeigen. ..................................................................................................... 151Servicerollen-Problem: Die Servicerolle konnte nicht erstellt werden. ............................................... 151Servicerollen-Problem: Die Servicerolle ist ungültig oder fehlt. ........................................................ 151Projektrollen-Problem: Die AWS Elastic Beanstalk Zustandsprüfungen schlagen bei Instances in einemAWS CodeStar-Projekt fehl ....................................................................................................... 152Projektrollen-Problem: Eine Projektrolle ist ungültig oder fehlt. ........................................................ 152Projekterweiterungen: Keine Verbindung zu JIRA möglich ............................................................. 153GitHub: Kein Zugriff auf den Commit-Verlauf eines Repositorys, Probleme oder Code ........................ 153

v


AWS CloudFormation: Stapelbildung wegen fehlender Berechtigungen zurückgerollt .......................... 153AWS CloudFormation ist nicht für die Ausführung von „iam:PassRole“ auf der LambdaAusführungsrolle autorisiert. ...................................................................................................... 154

Versionshinweise ............................................................................................................................. 155AWS-Glossar .................................................................................................................................. 158

vi

AWS CodeStar BenutzerhandbuchWofür kann ich AWS CodeStar verwenden;?

Was ist AWS CodeStar?AWS CodeStar ist ein Cloud-basierter Service, um Software-Entwicklungsprojekte auf AWS zuerstellen, zu verwalten und mit diesen zu arbeiten. Sie können auf AWS Anwendungen mit einem AWSCodeStar-Projekt schnell entwickeln, erstellen und bereitstellen. Ein AWS CodeStar-Projekt erstellt undintegriert AWS-Services für Ihre Projektentwicklungs-Tool-Chain. Je nach Wahl der AWS CodeStar-Projektvorlage kann diese Toolchain die Versionskontrolle, den Build, die Bereitstellung, virtuelleServer oder serverlose Ressourcen und vieles mehr beinhalten. AWS CodeStar verwaltet auch die fürProjektbenutzer erforderlichen Berechtigungen (Teammitglieder genannt). Durch das Hinzufügen vonBenutzern als Teammitglieder zu einem AWS CodeStar-Projekt können Projekteigentümer den einzelnenTeammitgliedern schnell und einfach ihrer Rolle entsprechenden Zugriff auf ein Projekt und die zugehörenRessourcen gewähren.

Das folgende Video stellt eine kurze Einführung in AWS CodeStar bereit: An Introduction to AWS CodeStar

Themen• Wofür kann ich AWS CodeStar verwenden;? (p. 1)• Erste Schritte mit AWS CodeStar (p. 1)

Wofür kann ich AWS CodeStar verwenden;?Sie können AWS CodeStar verwenden, um Ihre Anwendungsentwicklung in der Cloud einzurichtenund Ihre Entwicklung über ein einzelnes, zentrales Dashboard zu verwalten. Insbesondere können SieFolgendes:

• Starten Sie neue Softwareprojekte innerhalb von Minuten auf AWS mithilfe von Vorlagen fürWebanwendungen, Web-Services und mehr: AWS CodeStar umfasst Projektvorlagen für verschiedeneProjektarten und Programmiersprachen. Da AWS CodeStar die Einrichtung übernimmt, sind alle IhrerProjektressourcen so konfiguriert, dass sie zusammenarbeiten.

• Verwalten des Projektzugriffs für Ihr Team: AWS CodeStar stellt eine zentrale Konsole bereit, in der SieProjektteammitgliedern die Rollen zuweisen können, die sie für den Zugriff auf Tools und Ressourcenbenötigen. Diese Berechtigungen werden automatisch auf alle in Ihrem Projekt verwendeten AWS-Services angewendet. Sie müssen also keine komplexen IAM-Richtlinien erstellen oder verwalten.

• Visualisieren, Betreiben und Zusammenarbeiten an Ihren Projekten an einem Ort: AWS CodeStarumfasst ein Projekt-Dashboard, das einen Überblick über das Projekt, die Tool-Chain und wichtigeEreignisse bereitstellt. Sie können die neuesten Projektaktivitäten überwachen, wie beispielsweiseaktuelle Code-Commits, und den Status Ihrer Code-Änderungen, Build-Ergebnisse und Bereitstellungennachverfolgen – und das alles über eine einzige Webseite. Sie können über ein einziges Dashboard dieVorgänge in dem Projekt überwachen und zu lösende Probleme analysieren.

• Schnelles Iterieren mit allen benötigten Tools: AWS CodeStar enthält eine integrierte Entwicklungs-Tool-Chain für Ihr Projekt. Teammitglieder übertragen Code und Änderungen werden automatischbereitgestellt. Die Integration mit der Problemverfolgung ermöglicht Teammitgliedern, nachzufassen,welche Aufgaben als Nächstes ausgeführt werden müssen. Sie und Ihr Team können in allen Phasen derCodebereitstellung schneller und effizienter zusammenarbeiten.

Erste Schritte mit AWS CodeStarSo sehen die ersten Schritte mit AWS CodeStar aus:

1

https://www.youtube.com/embed/UJwKsqPC-44

AWS CodeStar BenutzerhandbuchErste Schritte mit AWS CodeStar

1. Bereiten Sie sich auf die Verwendung von AWS CodeStar vor, indem Sie die Schritte in Einrichten vonAWS CodeStar (p. 3) befolgen.

2. Experimentieren Sie mit AWS CodeStar indem Sie die Schritte im Erste Schritte mit AWSCodeStar (p. 6)-Tutorial befolgen.

3. Teilen Sie Ihr Projekt mit anderen Entwicklern, indem Sie die Schritte in Hinzufügen vonTeammitgliedern zu einem AWS CodeStar-Projekt (p. 96) ausführen.

4. Integrieren Sie Ihre bevorzugte IDE, indem Sie den Schritten in Verwenden einer IDE für AWSCodeStar (p. 56) folgen.

2

AWS CodeStar BenutzerhandbuchSchritt 1: Erstellen eines AWS-Kontos

Einrichten von AWS CodeStarBevor Sie AWS CodeStar verwenden können, müssen Sie die folgenden Schritte ausführen.

Themen• Schritt 1: Erstellen eines AWS-Kontos (p. 3)• Schritt 2: Erstellen der AWS CodeStar-Servicerolle (p. 3)• Schritt 3: Konfigurieren der IAM-Berechtigungen für Benutzer (p. 3)• Schritt 4:Erstellen eines Amazon EC2-Schlüsselpaars für AWS CodeStar-Projekte (p. 5)• Schritt 5: Öffnen der AWS CodeStar-Konsole (p. 5)• Nächste Schritte (p. 5)

Schritt 1: Erstellen eines AWS-KontosErstellen Sie ein AWS-Konto. Rufen Sie dazu https://aws.amazon.com/ auf und wählen Sie Sign Up(Anmelden) aus.

Schritt 2: Erstellen der AWS CodeStar-ServicerolleErstellen Sie eine Service-Rolle (p. 117) die verwendet wird, um AWS-Ressourcen und IAM-Berechtigungen zu erstellen und zu verwalten. Sie müssen die Servicerolle nur einmal erstellen.

Important

Sie müssen als administrativer IAM-Benutzer (oder im Stammkonto) angemeldet sein, um eineService-Rolle erstellen zu können. Weitere Informationen finden Sie unter Erstellen Ihrer erstenIAM-Benutzer- und Gruppe.

1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar/.2. Wählen Sie Start project (Projekt starten).

Wenn Start project (Projekt starten) nicht angezeigt wird und Sie stattdessen zur Seite mit derProjektliste weitergeleitet werden, wurde die Servicerolle bereits erstellt. Fahren Sie mit Konfigurierenvon Berechtigungen für IAM-Benutzer (p. 4) fort.

3. Wählen Sie im Dialogfeld Create service role (Service-Rolle erstellen) die Option Yes, create role (Ja,Rolle anlegen).

4. Verlassen Sie den Assistenten. Sie werden später an diesen Punkt zurückkehren.

Schritt 3: Konfigurieren der IAM-Berechtigungen fürBenutzer

Sie können AWS CodeStar als IAM-Benutzer, verbundener Benutzer, Root-Benutzer oder übernommeneRolle verwenden. Wenn Sie einen IAM-Benutzer auswählen, hilft Ihnen AWS CodeStar bei derKonfiguration des Benutzerzugriffs, indem es die IAM-Berechtigungen für Sie verwaltet. Informationen

3

https://aws.amazon.com/

https://docs.aws.amazon.com/IAM/latest/UserGuide/getting-started_create-admin-group.html


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

AWS CodeStar BenutzerhandbuchKonfigurieren von Berechtigungen für IAM-Benutzer

darüber, was AWS CodeStar für IAM-Benutzer im Vergleich zu verbundenen Benutzern tun kann, findenSie unter AWS CodeStar-Zugriffsberechtigungen – Referenz (p. 112).

Wenn Sie noch keine IAM-Benutzer erstellt haben, siehe IAM-Benutzer.

Konfigurieren von Berechtigungen für IAM-BenutzerFühren Sie die folgenden Schritte aus, um Berechtigungen für IAM-Benutzer einzurichten.

1. Um diesen Schritt auszuführen, müssen Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzer im Konto oder als IAM-Benutzer oder verbundener Benutzer mit der zugehörigenVerwaltungsrichtlinie oder ähnlichem in der IAM-Konsole angemeldet haben. Fügen Sie die verwalteteRichtlinie AWSCodeStarFullAccess dem IAM Benutzer an, die verwendet wird, um das Projekt zuerstellen.

2. Melden Sie sich bei der AWS CodeStar-Konsole als IAM-Benutzer mit zugeteilterAWSCodeStarFullAccess an, der das Projekt erstellen wird, und erstellen Sie dann Ihr Projekt.Einzelheiten dazu finden Sie unter Schritt 1: Erstellen eines AWS CodeStar-Projekts (p. 6). AWSCodeStar erstellt die verwalteten Richtlinien für Eigentümer, Beitragender und Betrachter für das Projekt.Nachdem Sie das Projekt erstellt haben, werden Ihre Berechtigungen des Projektverantwortlichenautomatisch übernommen.

3. Nachdem Sie Ihr Projekt erstellt haben, können Sie mit Ihren Berechtigungen weitere IAM-Benutzer alsTeammitglieder zu Ihrem Projekt hinzufügen. Weitere Informationen finden Sie unter Verwaltung vonBerechtigungen für AWS CodeStar-Teammitglieder (p. 100).

4. Wenn Ihr IAM-Benutzer bereits einem oder mehreren AWS CodeStar-Projekten hinzugefügt wurde, hatdieser bereits die Richtlinien und Berechtigungen für den Zugriff auf den Service und die Ressourcenfür die Projekte, zu denen Sie gehören. Gehen Sie zur Einrichtung Ihres Computers für die Arbeit mitAWS CodeStar-Projekten gemäß den Schritten in Erste Schritte (p. 12) vor. Sie können sich auchbei der AWS CodeStar-Konsole anmelden und Ihr Benutzerprofil konfigurieren. Weitere Informationenfinden Sie unter Verwalten von Anzeigeinformationen für Ihr AWS CodeStar-Benutzerprofil (p. 105)und Hinzufügen eines öffentlichen Schlüssels zu Ihrem AWS CodeStar-Benutzerprofil (p. 108).

Berechtigungen für verbundene BenutzerkonfigurierenUm AWS CodeStar als verbundener Benutzer zu verwenden, muss der verbundene Benutzer über IAM-Berechtigungen verfügen, die dem Benutzer die Verwendung von AWS CodeStar-APIs und den Zugriff aufalle Ressourcen in den Projekten gestatten (z. B. Amazon EC2 oder AWS Lambda).

Wenn Sie noch keine verbundenen Benutzer erstellt haben, siehe Zugriff für verbundene Benutzer aufAWS CodeStar (p. 138)

Führen Sie die folgenden Schritte aus, um Berechtigungen für verbundene Benutzer einzurichten:

1. Melden Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzer im Konto oder als IAM-Benutzer oder verbundener Benutzer mit der zugehörigen Richtlinie AdministratorAccess oder ähnlichemin der IAM-Konsole an. Fügen Sie die verwaltete Richtlinie AWSCodeStarFullAccess der Rollefür verbundene Benutzer an, die verwendet wird, um das Projekt zu erstellen. Siehe Anfügen derverwalteten Richtlinie AWSCodeStarFullAccess an die Rolle des verbundenen Benutzers. (p. 139).

2. Melden Sie sich bei der AWS CodeStar-Konsole als IAM-Benutzer mit zugeteilterAWSCodeStarFullAccess an, der das Projekt erstellen wird, und erstellen Sie dann Ihr Projekt.Einzelheiten dazu finden Sie unter Schritt 1: Erstellen eines AWS CodeStar-Projekts (p. 6). AWSCodeStar erstellt die verwalteten Richtlinien für Eigentümer, Beitragender und Betrachter für das Projekt.Als Ersteller des verbundenen Benutzerprojekts werden die Berechtigungen des Projektverantwortlichennicht automatisch angewendet. Möglicherweise können Sie nicht auf alle Projektressourcen zugreifen.

4

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html


AWS CodeStar BenutzerhandbuchSchritt 4:Erstellen eines Amazon EC2-

Schlüsselpaars für AWS CodeStar-Projekte

3. Um sich Zugriff auf alle Projektressourcen zu verschaffen, melden Sie sich entweder als Root-Benutzer,IAM-Administratorbenutzer im Konto oder als IAM-Benutzer oder Verbundbenutzer mit der zugehörigenverwalteten Richtlinie AdministratorAccess oder ähnlichem an der Konsole an. Fügen Sie die vomEigentümer verwaltete Richtlinie Ihres AWS CodeStar-Projekts der Rolle hinzu, die Sie als verbundenerBenutzer übernehmen. Auf diese Weise können Sie alle für Ihr Projekt erstellten Ressourcen verwaltenund anzeigen. Weitere Informationen finden Sie unter Fügen Sie die verwaltete AWS CodeStarBetrachter/Beitragender/Eigentümer-Richtlinie Ihres Projekts der Rolle des verbundenen Benutzershinzu. (p. 139).

4. Melden Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzer im Konto oder als IAM-Benutzer oder verbundener Benutzer mit der zugehörigen Richtlinie AdministratorAccess oder ähnlichemin der Konsole an. Gewähren Sie föderierten Benutzern Zugriff auf Ihr Projekt, indem Sie der Rolle desBenutzers die entsprechenden AWS CodeStar-Eigentümer, Beitragenden oder Betrachter verwaltetenRichtlinien hinzufügen. Weitere Informationen finden Sie unter Fügen Sie die verwaltete AWS CodeStarBetrachter/Beitragender/Eigentümer-Richtlinie Ihres Projekts der Rolle des verbundenen Benutzershinzu. (p. 139).

Schritt 4:Erstellen eines Amazon EC2-Schlüsselpaars für AWS CodeStar-Projekte

Viele AWS CodeStar-Projekte verwenden AWS CodeDeploy oder AWS Elastic Beanstalk zur Bereitstellungvon Code für Amazon EC2-Instances. Um auf mit Ihrem Projekt verbundene Amazon EC2-Instanceszuzugreifen, erstellen Sie ein Amazon EC2-Schlüsselpaar für Ihren IAM-Benutzer. Ihr IAM-Benutzermuss über Berechtigungen zum Erstellen und Verwalten von Amazon EC2-Schlüsseln verfügen (z. B.die Berechtigung, die Aktionen ec2:CreateKeyPair und ec2:ImportKeyPair auszuführen). WeitereInformationen finden Sie unter Amazon EC2-Schlüsselpaare.

Schritt 5: Öffnen der AWS CodeStar-KonsoleMelden Sie sich bei der AWS Management Console an und öffnen Sie die AWS CodeStar-Konsole unterhttps://console.aws.amazon.com/codestar/.

Nächste SchritteHerzlichen Glückwunsch, Sie haben die Einrichtung abgeschlossen! Informationen zum Einstieg in dieArbeit mit AWS CodeStar finden Sie unter Erste Schritte mit AWS CodeStar (p. 6).

5

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html


AWS CodeStar BenutzerhandbuchSchritt 1: Erstellen eines AWS CodeStar-Projekts

Erste Schritte mit AWS CodeStarIn diesem Tutorial verwenden Sie AWS CodeStar um eine Webanwendung zu erstellen. Dieses Projektenthält Beispiel-Code in einem Quell-Repository, eine kontinuierliche Tool-Chain für die Bereitstellung undein Projekt-Dashboard, auf dem Sie Ihr Projekt anzeigen und überwachen können.

Wenn Sie diese Schritte ausführen, führen Sie folgende Aktionen aus:

• Erstellen Sie ein Projekts in AWS CodeStar.• Entdecken des Projekts• Durchführen eines Commits für eine Codeänderung• Automatisches Bereitstellen Ihrer Codeänderungen• Hinzufügen von anderen Personen zur Arbeit an Ihrem Projekt• Bereinigen der Projektressourcen, wenn diese nicht mehr benötigt werden

Note

Wenn Sie dies noch nicht getan haben, führen Sie zunächst die Schritte zum Einrichten von AWSCodeStar (p. 3) aus, einschließlich Schritt 2: Erstellen der AWS CodeStar-Servicerolle (p. 3).Sie müssen mit einem Konto angemeldet sein, das ein administrativer Benutzer in IAM ist.Um ein Projekt zu erstellen, müssen Sie sich mit einem IAM-Benutzer, der über die RichtlinieAWSCodeStarFullAccess verfügt, bei der AWS Management Console anmelden.

Themen• Schritt 1: Erstellen eines AWS CodeStar-Projekts (p. 6)• Schritt 2: Hinzufügen von Anzeigeinformationen für Ihr AWS CodeStar-Benutzerprofil (p. 9)• Schritt 3: Anzeigen Ihres Projekts (p. 9)• Schritt 4: Anpassen der Kachel „Team Wiki” und des Projekt-Dashboards (p. 10)• Schritt 5: Durchführen des Commits für eine Änderung (p. 11)• Schritt 6: Hinzufügen von weiteren Teammitgliedern (p. 15)• Schritt 7: Bereinigen (p. 18)• Schritt 8: Machen Sie Ihr Projekt für eine Produktionsumgebung bereit. (p. 19)• Nächste Schritte (p. 19)• Tutorial: Erstellen und Verwalten einer serverlosen Projekts in AWS CodeStar (p. 19)• Tutorial: Erstellen eines Projekts in AWS CodeStar mit der AWS CLI (p. 31)• Tutorial: Erstellen eines Alexa-Skill-Projekts in AWS CodeStar (p. 36)

Schritt 1: Erstellen eines AWS CodeStar-ProjektsIn diesem Schritt erstellen Sie ein JavaScript-Softwareentwicklungsprojekt (Node.js) für eineWebanwendung. Sie verwenden eine Projektvorlage für AWS CodeStar, um das Projekt zu erstellen.

Note

Die in diesem Tutorial verwendete Projektvorlage für AWS CodeStar verwendet die folgendenOptionen:

• Application category (Anwendungskategorie): Webanwendung• Programming language (Programmiersprache): Node.js• AWS-Service: Amazon EC2

6


Wenn Sie andere Optionen wählen, entspricht Ihre Umgebung ggf. nicht den Beschreibungen indiesem Tutorial.

So erstellen Sie ein Projekt in AWS CodeStar

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die AWS CodeStar-Konsoleunter https://console.aws.amazon.com/codestar/.

Stellen Sie sicher, dass Sie sich bei der AWS-Region, in der Sie das Projekt und seine Ressourcenerstellen möchten, angemeldet haben. Wenn Sie beispielsweise ein Projekt in der Region USA Ost(Ohio) erstellen möchten, achten Sie darauf, dass Sie diese Region ausgewählt haben. Informationenüber die AWS-Regionen, in denen AWS CodeStar verfügbar ist, finden Sie unter Regionen undEndpunkte in der Allgemeinen AWS-Referenz.

2. Wählen Sie auf der Seite AWS CodeStar die Option Create a new project (Neues Projekt erstellen).(Wenn Sie der erste Benutzer sind, der ein Projekt erstellt, wählen Sie Start a project (Starten einesProjekts).)

3. Wählen Sie auf der Seite Choose a project template (Wählen einer Projektvorlage) aus der Listevon Projektvorlagen für AWS CodeStar die Art des Projekts aus. Sie können die Auswahl mithilfeder Filterleiste eingrenzen. Zum Beispiel: Markieren Sie für eine Webanwendung in Node.js, diefür Amazon EC2-Instances bereitgestellt werden soll, die Kontrollkästchen Web application (Web-Anwendung), Node.js und Amazon EC2. Wählen Sie dann aus den Vorlagen für diese Optionen aus.

Weitere Informationen finden Sie unter AWS CodeStar-Projektvorlagen (p. 41).4. Geben Sie unter Project name (Projektname) einen Namen für das Projekt ein, etwa Mein erstes

Projekt. Die ID für das Projekt wird aus diesem Projektnamen abgeleitet, ist jedoch auf 15 Zeichenbeschränkt.

Beispielsweise ist die Standard-ID für ein Projekt mit dem Namen Mein erstes Projekt „my-first-projec“. Diese Projekt-ID ist die Grundlage für die Namen aller mit dem Projekt verbundenenRessourcen. AWS CodeStar verwendet diese Projekt-ID als Teil der URL für Ihr Code-Repositoryund für die Namen der zugehörigen Rollen und Richtlinien für den Sicherheitszugriff in IAM. Nach derErstellung des Projekts kann die Projekt-ID nicht mehr geändert werden. Wählen Sie zur Bearbeitungder Projekt-ID vor der Erstellung des Projekts die Option Edit (Bearbeiten).

Informationen zu den Einschränkungen für Projektnamen und Projekt-IDs finden Sie unterEinschränkungen in AWS CodeStar (p. 145).

Note

Projekt-IDs für Ihr AWS-Konto müssen innerhalb einer AWS-Region eindeutig sein.5. Wählen Sie die Repository-Anbieter AWS CodeCommit oder GitHub.6. Wenn Sie AWS CodeCommit als Repository name (Repository-Namen) wählen, übernehmen Sie den

Standardnamen des AWS CodeCommit-Repository, oder geben Sie einen anderen Namen ein. FahrenSie dann mit Schritt 8 fort.

7. Wenn Sie GitHub gewählt haben, wählen Sie Connect with GitHub (Mit GitHub verbinden).

1. Wenn die Seite Sign in to GitHub (Bei GitHub anmelden) angezeigt wird, geben Sie Ihren GitHub-Benutzernamen oder die E-Mail-Adresse und das Passwort ein, und wählen Sie dann Sign in(Anmelden).

Note

Sie müssen über ein GitHub-Konto verfügen, um diese Seite auszufüllen. WeitereInformationen finden Sie unter Join GitHub Jenkins auf der GitHub-Website.

2. Wenn die Seite für die Two-factor authentication (Zwei-Faktor-Authentifizierung) angezeigt wird,geben Sie für Authentication code (Authentifizierungscode) den Code ein, den GitHub Ihnen sendet,und wählen Sie dann Verify (Überprüfen).

7


https://docs.aws.amazon.com/general/latest/gr/rande.html#codestar_region


https://github.com/join


3. Wählen Sie auf der Seite Authorize AWS CodeStar (AWS CodeStar genehmigen) die OptionAuthorize application (Anwendung genehmigen).

Note

Wenn Sie die Option Authorize (Genehmigen) wählen, erlauben Sie AWS CodeStarein GitHub-Repository für Ihr persönliches GitHub-Konto zu erstellen, oder für einebeliebige GitHub-Organisation, wo Sie über Berechtigungen verfügen. (Ein grünesHäkchen in Organization access (Organisationszugriff) wird verwendet, um Berechtigungenanzugeben.)Um eine GitHub-Organisation zur Liste Organization access (Organisationszugang)hinzuzufügen, folgen Sie den Anweisungen unter Benutzer einladen, Ihrer Organisationbeizutreten auf der GitHub Help-Website. Nachdem Sie der Organisation beigetreten sind,aktualisieren Sie die Seite Authorize AWS CodeStar (AWS CodeStar genehmigen), um dieOrganisation in der Liste anzuzeigen.Um Berechtigungen für die Autorisierung einer GitHub-Organisation zu erhalten, die sichin der Liste befindet, aber keinen grünen Haken hat, wählen Sie Grant (Gestatten). WennSie stattdessen Request (Anfordern) sehen, wählen Sie es aus und folgen Sie dann denAnweisungen unter Genehmigen von OAuth-Apps für Ihre Organisation auf der GitHubHelp-Website. Aktualisieren Sie die Seite Authorize AWS CodeStar (AWS CodeStargenehmigen), um die Schaltfläche Grant (Genehmigen) anzuzeigen.

4. Für Owner (Besitzer) wählen Sie die GitHub-Organisation oder Ihr privates GitHub-Konto.5. Für Repository name (Repository-Name) übernehmen Sie den Standardnamen des GitHub-

Repository, oder geben Sie einen anderen Namen ein.6. Wählen Sie Public repository (Öffentliches Repository) oder Private repository (Privates Repository).

Note

Abhängig vom Typ Ihres GitHub-Kontos gestattet Ihnen GitHub Ihnen möglicherweisenicht, ein privates Repository zu erstellen. Weitere Informationen finden Sieunter GitHub Pricing auf der GitHub-Website. Wenn Sie AWS Cloud9 ebenso alsEntwicklungsumgebung verwenden möchten, müssen Sie ein öffentliches Repositoryauswählen.

7. (Optional) Für Repository description geben Sie eine Beschreibung für das GitHub-Repository ein.8. Wählen Sie Next.9. Überprüfen Sie die Ressourcen und Konfigurationsdetails. Wählen Sie Edit Amazon EC2 Configuration

(Amazon EC2-Konfiguration bearbeiten) (falls verfügbar), wenn Ihr Projekt für Amazon EC2-Instancesbereitgestellt ist und Sie Änderungen vornehmen möchten. Sie können beispielsweise aus denverfügbaren Instance-Typen für Ihr Projekt eine Auswahl treffen.

Note

Unterschiedliche Amazon EC2-Instance-Typen bieten ein unterschiedliches Maß anRechenleistung und können mit unterschiedlichen Kosten verbunden sein. WeitereInformationen finden Sie unter Amazon EC2-Instance-Typen und Amazon EC2-Preise.Wenn Sie mehr als eine Virtual Private Cloud (VPC) oder mehrere Subnetze in AmazonVirtual Private Cloud erstellt haben, können Sie die VPC und das Subnetz zur Verwendungauswählen. Wenn Sie jedoch einen Amazon EC2-Instance-Typ wählen, der auf DedicatedInstances nicht unterstützt wird, können Sie keine VPC wählen, deren Instance-Tenancy aufDedicated (Dediziert) gesetzt ist.Weitere Informationen finden Sie unter Was ist Amazon VPC? und Dedicated Instance –Grundlagen.

10. Lassen Sie das Kontrollkästchen AWS CodeStar would like permission to administer AWS resourceson your behalf (AWS CodeStar möchte die Erlaubnis, AWS-Ressourcen in Ihrem Namen zu verwalten)ausgewählt. Andernfalls können Sie kein Projekt erstellen. Weitere Informationen über die Service-Rolle finden Sie unter Richtlinie und Berechtigungen für die AWS CodeStar Service-Rolle (p. 117).

8

https://help.github.com/articles/inviting-users-to-join-your-organization/


https://help.github.com/articles/approving-oauth-apps-for-your-organization/

https://github.com/pricing

https://aws.amazon.com/ec2/instance-types/

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

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Introduction.html

https://docs.aws.amazon.com/vpc/latest/userguide/dedicated-instance.html#dedicated-howitworks


AWS CodeStar BenutzerhandbuchSchritt 2: Hinzufügen von Anzeigeinformationen

für Ihr AWS CodeStar-Benutzerprofil

Wählen Sie Next (Weiter) oder Create project (Projekt erstellen). (Die angezeigte Wahlmöglichkeithängt von Ihrer Projektvorlage ab.)

11. Wählen Sie unter Choose an Amazon EC2 Key Pair (Ein Amazon EC2-Schlüsselpaar auswählen)das Amazon EC2-Schlüsselpaar, das Sie in Schritt 4:Erstellen eines Amazon EC2-Schlüsselpaarsfür AWS CodeStar-Projekte (p. 5) erstellt haben. Wählen Sie I acknowledge that I have access to theprivate key file for this key pair (Ich bestätige, dass ich Zugriff auf die private Schlüsseldatei für diesesSchlüsselpaar habe) und dann Create project (Projekt erstellen).

12. Das Erstellen des Projekts (einschließlich des Repositorys) kann einige Minuten dauern. SobaldIhr Projekt ein Repository hat, können Sie auf der Seite Set up tools (Tools einrichten) den Zugriffdarauf konfigurieren. Sie können auch Skip (Überspringen) wählen, um diese Konfiguration spätervorzunehmen. Nachdem Ihr Projekt erstellt wurde, können Sie die Links auf der Kachel Welcome(Willkommen) verwenden, um andere Elemente zu konfigurieren, wie z.B. Ihr Benutzerprofil in AWSCodeStar (p. 105).

Schritt 2: Hinzufügen von Anzeigeinformationen fürIhr AWS CodeStar-Benutzerprofil

Wenn Sie ein Projekt erstellen, werden Sie als Eigentümer zum Projekt hinzugefügt. Wenn dies das ersteMal ist, dass Sie AWS CodeStar verwenden, werden Sie gebeten, Folgendes anzugeben:

• Ihren Anzeigenamen, der anderen Benutzern angezeigt werden soll.• Die E-Mail-Adresse, die anderen Benutzern angezeigt werden soll

Diese Informationen werden in Ihrem AWS CodeStar-Benutzerprofil verwendet. Benutzerprofile sindnicht projektspezifisch, jedoch auf eine AWS-Region begrenzt. Sie müssen in jeder AWS-Region einBenutzerprofil erstellen, in der Sie zu Projekten gehören. Jedes Profil kann verschiedene Informationenenthalten, wenn Sie möchten.

Geben Sie einen Benutzernamen und eine E-Mail-Adresse ein, und klicken Sie dann auf Next (Weiter).

Note

Dieser Benutzername und diese E-Mail-Adresse werden in Ihrem AWS CodeStar-Benutzerprofilverwendet. Wenn Ihr Projekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. einGitHub-Repository oder Elemente in Atlassian JIRA), können diese Ressourcenanbieter ihreeigenen Benutzerprofile mit unterschiedlichen Benutzernamen und E-Mail-Adressen aufweisen.Weitere Informationen finden Sie in der Dokumentation des Ressourcenanbieters.

Schritt 3: Anzeigen Ihres ProjektsDas AWS CodeStar-Projekt-Dashboard ist der Bereich, in dem Sie und Ihr Team den Status IhrerProjektressourcen anzeigen, einschließlich der neuesten Commits zu Ihrem Projekt, des Status Ihrerkontinuierlichen Bereitstellungs-Pipeline und der Leistung Ihrer Instances. Diese Informationen werden inKacheln angezeigt, die für eine Ressource vorgesehen sind. Weitere Informationen zu diesen Ressourcenerhalten Sie, indem Sie den Detaillink auf der Kachel wählen. Die Konsole für diesen AWS-Service öffnetsich auf der Detailseite dieser Ressource.

Sie können den Anzeigeort der einzelnen Kacheln auf Ihrem Dashboard ändern, indem Sie diese ziehenund an einer neuen Position ablegen. Sie können auch das Ellipsenmenü auf den einzelnen Kachelnverwenden, um diese aus dem Menü zu entfernen. Um eine Kachel hinzuzufügen, wählen Sie imDashboard Add tile (Titel hinzufügen).

9

AWS CodeStar BenutzerhandbuchSchritt 4: Anpassen der Kachel „Team

Wiki” und des Projekt-Dashboards

In Ihrem neuen Projekt sehen Sie die folgenden Kacheln:

• Die Kachel Welcome (Willkommen) enthält Links zu Aktionen, die Sie möglicherweise ausführenmöchten. Im Gegensatz zu anderen Kacheln können Sie diese Kachel nicht an einen anderen Standortverschieben oder sie erneut hinzufügen, nachdem Sie sie geschlossen haben.

• Die Kachel Continuous deployment (Durchgehende Bereitstellung) zeigt eine Übersicht derdurchgehenden Bereitstellungs-Pipeline für Ihr Projekt. Die Pipeline stellt den Code der Webanwendungbei einer Änderung in Ihrem Repository bereit. Da Ihr Projekt neu ist, beginnt die Pipeline sofort mitder Bereitstellung des Beispiel-Codes. Sie können die Verarbeitung und den Abschluss der einzelnenPhasen bei der Bereitstellung Ihrer Webanwendung anzeigen.

Sie können auch prüfen, ob in einer Stufe ein Problem aufgetreten oder eine Genehmigung erforderlichist. Um Informationen zum Status der Pipeline, ihrer Phasen und Aktionen anzuzeigen, oder umÄnderungen vorzunehmen, wie beispielsweise eine Phase hinzufügen oder bearbeiten, wählen SieCodePipeline details (AWS CodePipeline-Details).

• Die Kachel Application endpoints (Anwendungsendpunkte) zeigt Links zu den Endpunkten, auf denenSie Ihre Software anzeigen können. Wählen Sie den Link, um Ihre Anwendung oder Ihren Serviceanzuzeigen.

• Die Kachel Commit history (Commit-Verlauf) zeigt den neuesten Commit-Verlauf des Repositorys an.Wenn Sie ein Projekt erstmalig erstellen, ist der letzte Commit der von AWS CodeStar vorgenommene.Dieser Commit begann mit der Ausführung des Beispiel-Codes über die Pipeline. Wenn Sie einenanderen Commit vornehmen, erscheint er ebenfalls im Verlauf. Diese Codeänderung wird automatischüber die Pipeline ausgeführt. Um die Commits einer anderen Verzweigung anzuzeigen, verwenden Siedie Auswahlschaltfläche für die Verzweigung. Um alle Commits oder andere Details über die Commitsoder das Repository anzuzeigen, wählen Sie CodeCommit details (AWS CodeCommit-Details) (falls derCode in CodeCommit gespeichert ist) oder Open in GitHub (In GitHub öffnen) (falls der Quellcode inGitHub gespeichert ist).

• Die Kachel Application activity (Anwendungsaktivität) zeigt Amazon CloudWatch-Metriken für Ihr Projektan. Beispielsweise zeigt sie die CPU-Auslastung aller von AWS Elastic Beanstalk- oder CodeDeploy-Ressourcen in Ihrer Pipeline bereitgestellten Amazon EC2-Instances an. In Projekten, die AWS Lambdaverwenden, zeigt Sie Metriken zu Aufrufen und Fehlern für die Lambda-Funktion an. Diese Informationenwerden stundenweise angezeigt. Wenn Sie die empfohlenen Projektvorlage für AWS CodeStar in diesemTutorial verwendet haben, sollten Sie einen deutlichen Spitzenwert in der Aktivität feststellen, wenn IhreAnwendung erstmals für diese Instances bereitgestellt wird. Sie können die Überwachung aktualisieren,um Änderungen am Zustand Ihrer Instance zu erkennen. Dies kann Ihnen dabei helfen, Probleme oderden Bedarf an weiteren Ressourcen zu erkennen.

Note

Wenn Ihr AWS CodeStar-Projekt mehr als eine Metrik enthält, können Sie die Anzeige filtern,indem Sie eine bestimmte Metrik in der Kachel auswählen.

• Die Kachel JIRA dient der Integration Ihres AWS CodeStar-Projekts in ein bestehendes Atlassian JIRA-Projekt. Die Konfiguration dieser Kachel ermöglicht es Ihnen und Ihrem Projektteam, JIRA-Problemeüber das Projekt-Dashboard zu verfolgen. Um diese Kachel zu konfigurieren, wählen Sie Connect(Verbinden) und befolgen Sie dann die Anweisungen.

• Es gibt auch die Kachel Team wiki (Team-Wiki). Sie können den Inhalt dieser Kachel so anpassen, dassTeamnotizen darin enthalten sind, Links zu hilfreichen Ressourcen für Ihr Teamprojekt oder Beispielebereitgestellt werden und so weiter. Die Anpassung dieser Kachel erfolgt im nächsten Schritt.

Schritt 4: Anpassen der Kachel „Team Wiki” unddes Projekt-Dashboards

Jedes AWS CodeStar-Projekt enthält eine anpassbare Team-Wiki-Kachel, die für einen bestimmten Zweckverwendet werden kann (z. B. zum Hinzufügen von Links zu Teamressourcen oder zum Anzeigen von

10

AWS CodeStar BenutzerhandbuchSchritt 5: Durchführen des Commits für eine Änderung

Codeausschnitten für einen bevorzugten Entwicklungsstil). Diese Kachel unterstützt sowohl Klartext alsauch formatierte Inhalte. In diesem Schritt passen Sie diese Kachel so an, dass sie einen Link zum AWS-DevOps-Blog enthält.

Anpassen der Team-Wiki-Kachel

1. Wählen Sie auf der Team-Wiki-Kachel im Projekt-Dashboard das Ellipsenmenü und anschließend Edit(Bearbeiten).

2. Geben Sie unter Widget title (Widget-Titel) Team links ein. Fügen Sie in Markdown content (Inhaltherabsetzen) ein Element zur Liste hinzu und fügen Sie Folgendes ein:

[AWS DevOps Blog](https://aws.amazon.com/blogs/devops/)

Wählen Sie Save aus.3. Wählen Sie den Link auf der Kachel, um diesen zu testen.

Anpassen der Darstellung Ihres Dashboards

1. Wählen Sie eine Kachel auf dem Dashboard aus. Ziehen Sie sie an eine neue Position. Sie könnenDashboard-Kacheln neu anordnen, um sicherzustellen, dass die für Sie wichtigste Information an deram besten sichtbaren Positionen erscheint.

2. Um eine Kachel zu entfernen, wählen Sie das Ellipsenmenü (…) auf dieser Kachel und anschließendRemove from Dashboard (Vom Dashboard entfernen).

3. Um eine Kachel hinzuzufügen, wählen Sie Add tile (Kachel hinzufügen) oben im Dashboard undanschließend die Kachel, die hinzugefügt werden soll. Sie können von jeder Art Kachel nur eine aufIhrem Dashboard verwenden.

Schritt 5: Durchführen des Commits für eineÄnderung

Sehen Sie sich zuerst den Beispiel-Code an, der in Ihrem Projekt enthalten war, und sehen Sie sich an,wie die Anwendung aussieht. Wählen Sie auf der Kachel Application endpoints (Anwendungsendpunkte)den Link in Ihren Endpunkt. Ihre Beispiel-Webanwendung wird in einem neuen Fenster oder einerneuen Registerkarte im Browser geöffnet. Dies ist das Projektbeispiel, das AWS CodeStar erstellt undimplementiert hat.

Wenn Sie sich den Code ansehen möchten, wählen Sie in der Navigationsleiste die Option Code. DasRepository Ihres Projekts wird in einer neuen Registerkarte oder einem neuen Fenster geöffnet. Lesen Sieden Inhalt der Readme-Datei (README.md) zum Repository und navigieren Sie durch den Inhalt dieserDateien.

In diesem Schritt ändern Sie den Code und speichern die Änderung in Ihrem Repository. Dafür stehenIhnen mehrere Optionen zur Verfügung:

• Wenn der Projektcode in einem CodeCommit- oder GitHub-Repository gespeichert ist, können Sie mitAWS Cloud9 direkt über Ihren Webbrowser mit dem Code arbeiten, ohne irgendwelche Werkzeuge zuinstallieren. Weitere Informationen finden Sie unter Erstellen Sie eine AWS Cloud9-Umgebung für einProjekt (p. 57).

• Wenn der Projektcode in einem CodeCommit-Repository gespeichert ist, und Sie Visual Studio oderEclipse installiert haben, können Sie die Verbindung mit dem Code einfacher mit AWS Toolkit for VisualStudio oder AWS Toolkit for Eclipse einrichten. Weitere Informationen finden Sie unter Verwenden einer

11


IDE für AWS CodeStar (p. 56). Wenn Sie Visual Studio oder Eclipse nicht installiert haben, danninstallieren Sie einen Git-Client und befolgen die späteren Anweisungen in diesem Schritt.

• Wenn der Projektcode in einem GitHub-Repository gespeichert ist, können Sie Ihre IDE-Tools für dieVerbindung zu GitHub verwenden.• Für Visual Studio können Sie Tools wie die GitHub-Erweiterung für Visual Studio verwenden. Weitere

Informationen finden Sie auf der Seite Overview der Website für die GitHub Extension für Visual Studiound auf der GitHub-Website unter Getting Started with GitHub for Visual Studio.

• Für Eclipse können Sie ein Tool wie EGit für Eclipse verwenden. Weitere Informationen finden Sieunter EGit Documentation auf der EGit-Website.

• Weitere Informationen über IDEs finden Sie in der Dokumentation Ihrer IDE.• Weitere Arten von Code-Repositorys finden Sie in der Dokumentation Ihres Repository-Anbieters.

Die folgenden Anweisungen zeigen Ihnen, wie Sie eine kleine Änderung am Beispiel vornehmen können.

So richten Sie Ihren Computer so ein, dass er Commits für Änderungen durchführt (IAM-Benutzer)

Note

In diesem Verfahren wird vorausgesetzt, dass der Code für Ihr Projekt in einem CodeCommit-Repository gespeichert ist. Weitere Informationen über Code-Repository-Typen finden Sie in derDokumentation Ihres Repository-Anbieters. Anschließend fahren Sie mit dem nächsten Verfahrenfort, So klonen Sie das Projekt-Repository und nehmen eine Änderung vor (p. 14).Wenn der Code in CodeCommit gespeichert ist und Sie bereits CodeCommit verwenden oderdie AWS CodeStar-Konsole verwendet haben, um eine AWS Cloud9-Entwicklungsumgebung fürdas Projekt zu erstellen, benötigen Sie keine weitere Konfiguration. Fahren Sie mit dem nächstenVerfahren fort, So klonen Sie das Projekt-Repository und nehmen eine Änderung vor (p. 14).

1. Installieren Sie Git auf Ihrem lokalen Computer.2. Melden Sie sich bei der AWS Management Console an und öffnen Sie die IAM-Konsole unter https://

console.aws.amazon.com/iam/.

Melden Sie sich als der IAM-Benutzer an, der mithilfe von GIT-Anmeldeinformationen Verbindungen zuIhrem AWS CodeStar-Projekt-Repository in CodeCommit herstellt.

3. Wählen Sie in der IAM-Konsole im Navigationsbereich die Option Users (Benutzer) aus und wählenSie in der Liste der Benutzer Ihren IAM-Benutzer aus.

4. Wählen Sie zuerst auf der Detailseite des Benutzers die Registerkarte Security Credentials(Sicherheitsanmeldeinformationen) und dann in HTTPS Git credentials for CodeCommit (HTTPS Git-Anmeldeinformationen für ACC) die Option Generate (Generieren) aus.

12

https://visualstudio.github.com/index.html

https://github.com/github/VisualStudio/blob/master/docs/getting-started/index.md

http://www.eclipse.org/egit/documentation/

https://git-scm.com/downloads

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



Note

Sie können nicht Ihren eigenen Benutzernamen oder das Passwort für Git-Anmeldeinformationen wählen. Weitere Informationen finden Sie unter Verwenden von Git-Anmeldeinformationen und HTTPS mit CodeCommit.

5. Kopieren Sie den Benutzernamen und das Passwort, das IAM für Sie erstellt hat. Sie können Show(Anzeigen) auswählen und diese Informationen anschließend kopieren und in einer sicheren Datei aufIhrem lokalen Computer einfügen. Alternativ können Sie Download credentials (Anmeldeinformationenherunterladen) auswählen, um diese Informationen als CSV-Datei herunterzuladen. Sie benötigendiese Informationen für die Verbindung mit CodeCommit.

Wählen Sie, nachdem Sie Ihre Anmeldeinformationen gespeichert haben, die Option Close aus.Important

Dies ist Ihre einzige Möglichkeit, den Benutzernamen und das Passwort zu speichern. WennSie sie nicht speichern, können Sie zwar den Benutzernamen aus der IAM-Konsole kopieren,das Passwort können Sie jedoch nicht nachsehen. Sie müssen das Passwort zurücksetzenund es dann speichern.

So richten Sie Ihren Computer so ein, dass er Commits für Änderungen durchführt (VerbundenerBenutzer)

Sie können die Konsole verwenden, um Dateien in Ihr Repository hochzuladen, oder Sie können Gitverwenden, um sich von Ihrem lokalen Computer aus zu verbinden. Wenn Sie einen verbundenen Zugriffverwenden, führen Sie die folgenden Schritte aus, um mit Git eine Verbindung zu Ihrem Repositoryherzustellen und es von Ihrem lokalen Computer aus zu klonen.

Note

In diesem Verfahren wird vorausgesetzt, dass der Code für Ihr Projekt in einem CodeCommit-Repository gespeichert ist. Weitere Informationen über Code-Repository-Typen finden Sie in derDokumentation Ihres Repository-Anbieters. Anschließend fahren Sie mit dem nächsten Verfahrenfort, So klonen Sie das Projekt-Repository und nehmen eine Änderung vor (p. 14).

1. Installieren Sie Git auf Ihrem lokalen Computer.2. Installieren der AWS CLI3. Konfigurieren Sie Ihre temporären Sicherheits-Anmeldeinformationen für einen verbundenen Benutzer.

Weitere Informationen finden Sie unter Temporärer Zugriff auf CodeCommit-Repositorys. TemporäreAnmeldeinformationen bestehen aus:

13

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_ssh-keys.html#git-credentials-code-commit

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_ssh-keys.html#git-credentials-code-commit


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

https://docs.aws.amazon.com/codecommit/latest/userguide/temporary-access.html


• AWS-Zugriffsschlüssel• AWS-Geheimschlüssel• Sitzungs-Token

Weitere Informationen über temporäre Sicherheitsanmeldeinformationen finden unter Berechtigungenfür GetFederationToken.

4. Verbinden Sie sich mit Ihrem Repository über den Anmeldehelfer von AWS CLI. Weitere Informationenfinden Sie unter Konfigurationsschritte für HTTPS-Verbindungen zu CodeCommit-Repositorysauf Linux, macOS oder Unix mit dem AWS CLI-Hilfsprogramm für Anmeldeinformationen oderKonfigurationsschritte für HTTPS-Verbindungen zu CodeCommit-Repositorys auf Windows mit demAWS CLI-Hilfsprogramm für Anmeldeinformationen

5. Das folgende Beispiel zeigt, wie man sich mit einem CodeCommit-Repository verbindet und einenCommit darauf auslöst.

Beispiel: So klonen Sie das Projekt-Repository und nehmen eine Änderung vor

Note

In diesem Verfahren wird gezeigt, wie Sie das Code-Repository Ihres Projekts auf Ihrem Computerklonen, die Datei index.html ändern und dann Ihre Änderungen im externen Repositoryspeichern. Bei diesem Verfahren gehen wir davon aus, dass der Code Ihres Projekts in einemCodeCommit-Repository gespeichert ist und dass Sie einen Git-Client über die Befehlszeileverwenden. Weitere Informationen über andere Code-Repositorys oder Tools finden Sie in derDokumentation des Anbieters dazu, wie Sie das Repository klonen, die Datei ändern und denCode speichern.

1. Wenn Sie die AWS CodeStar-Konsole zum Erstellen einer AWS Cloud9-Entwicklungsumgebung fürdas Projekt verwendet haben, öffnen Sie die Entwicklungsumgebung, und führen Sie anschließendSchritt 3 in dieser Anleitung fort. Informationen zum Öffnen der Entwicklungsumgebung finden Sieunter Öffnen einer AWS Cloud9-Umgebung für ein Projekt (p. 59).

Während Ihr Projekt in der AWS CodeStar-Konsole geöffnet ist, wählen Sie in der Navigationsleistedas Zahnradsymbol Project (Projekt) und klicken dann auf die Schaltfläche Connect tools (Toolsverbinden). Wählen Sie unter Clone repository URL (URL des Repository klonen) das Protokollfür den Verbindungstyp, den Sie für CodeCommit eingerichtet haben, und kopieren Sie dann denLink. Wenn Sie beispielsweise die Schritte im vorhergehenden Verfahren zum Einrichten der Git-Anmeldeinformationen für CodeCommit befolgt haben, wählen Sie HTTPS.

2. Öffnen Sie auf Ihrem lokalen Computer ein Terminal- oder ein Befehlszeilenfenster und ändern Sie dieVerzeichnisse in ein temporäres Verzeichnis. Führen Sie den Befehl git clone aus, um das Repositoryauf Ihren Computer zu klonen. Fügen Sie den kopierten Link ein. Zum Beispiel für CodeCommit überHTTPS:

git clone https://git-codecommit.us-east-2.amazonaws.com/v1/repos/my-first-projec

Wenn Sie zum ersten Mal die Verbindung herstellen, werden Sie aufgefordert, den Benutzernamenund das Passwort für das Repository einzugeben. Für CodeCommit geben Sie die Git-Anmeldeinformationen – Benutzername und Passwort – ein, die Sie im vorherigen Verfahrenheruntergeladen haben.

3. Navigieren Sie zu dem Klon-Verzeichnis auf Ihrem Computer und durchsuchen Sie die Inhalte.4. Öffnen Sie die index.html-Datei (im öffentlichen Ordner) und nehmen Sie eine Änderung an der

Datei vor. Fügen Sie beispielsweise nach dem <H2>-Tag einen Absatz hinzu, z. B.:

14

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_temp_control-access_getfederationtoken.html

https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-https-unixes.html

https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-https-unixes.html

https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-https-windows.html

https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-https-windows.html

AWS CodeStar BenutzerhandbuchSchritt 6: Hinzufügen von weiteren Teammitgliedern

<P>Hello, world!</P>

Speichern Sie die Datei.5. Fügen Sie an der Terminal- oder Eingabeaufforderung Ihre geänderte Datei hinzu, fügen Sie einen

Commit für eine Änderung durch und übertragen Sie diese:

git add index.htmlgit commit -m "Making my first change to the web app"git push

6. Zeigen Sie in Ihrem Projekt-Dashboard die vorgenommenen Änderungen an. Sie werden feststellen,dass der Commit-Verlauf für das Repository mit Ihrem Commit aktualisiert wird, einschließlich derCommit-Nachricht. Sie können auch sehen, dass die Pipeline Ihre Änderung am Repository erfasstund mit der Erstellung und Bereitstellung beginnt. Nachdem Ihre Webanwendung bereitgestellt wurde,können Sie die Links verwenden, die Sie der Projektinformationskachel hinzugefügt haben, um IhreÄnderung anzuzeigen.

Note

Wird für eine der Pipeline-Phasen Failed (Fehlgeschlagen) angezeigt, kann Ihnen Folgendesbei der Fehlersuche helfen:

• Weitere Informationen über die Source (Quelle)-Stufe finden Sie unter TroubleshootingAWS CodeCommit im AWS CodeCommit-Benutzerhandbuch.

• Weitere Informationen über die Build-Stufe finden Sie unter Troubleshooting AWSCodeBuild im AWS CodeBuild-Benutzerhandbuch.

• Weitere Informationen über die Deploy (Bereitstellen)-Stufe finden Sie unterTroubleshooting AWS CloudFormation im AWS CloudFormation Benutzerhandbuch.

• Informationen zu weiteren Problemen finden Sie unter AWS CodeStar-Fehlerbehebung (p. 147).

Schritt 6: Hinzufügen von weiteren TeammitgliedernJedes AWS CodeStar-Projekt ist bereits mit drei AWS CodeStar-Rollen konfiguriert. Jede Rolle bietet eineeigene Zugriffsebene auf das Projekt und seine Ressourcen:

• Eigentümer: Kann Teammitglieder hinzufügen und entfernen, das Projekt-Dashboard ändern und dasProjekt löschen.

• Beitragender: Kann das Projekt-Dashboard ändern und Code beitragen, wenn der Code in CodeCommitgespeichert ist, kann jedoch keine Teammitglieder hinzufügen oder entfernen oder das Projekt löschen.Dies ist die Rolle, die Sie für die meisten Teammitglieder in einem AWS CodeStar-Projekt wählen sollten.

• Betrachter: kann das Projekt-Dashboard, den Projektcode, wenn dieser in CodeCommit gespeichert ist,und den Status des Projekts anzeigen, kann jedoch keine Kacheln im Projekt-Dashboard verschieben,hinzufügen oder aus diesem entfernen.

Important

Wenn Ihr Projekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oder Probleme in Atlassian JIRA), wird der Zugriff auf diese Ressourcen vom

15

https://docs.aws.amazon.com/codecommit/latest/userguide/troubleshooting.html


https://docs.aws.amazon.com/codebuild/latest/userguide/troubleshooting.html


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


Ressourcenanbieter kontrolliert, nicht von AWS CodeStar. Weitere Informationen finden Sie in derDokumentation des Ressourcenanbieters.Jeder, der Zugriff auf ein AWS CodeStar-Projekt hat, ist möglicherweise in der Lage, die AWSCodeStar-Konsole für den Zugriff auf Ressourcen zu nutzen, die außerhalb von AWS liegen, aberim Zusammenhang mit dem Projekt stehen.AWS CodeStar erlaubt es den Mitgliedern des Projektteams nicht, an zugehörigen AWS Cloud9-Entwicklungsumgebungen für ein Projekt teilzunehmen. Wie Sie einem Teammitglied dieTeilnahme an einer gemeinsamen Umgebung ermöglichen, erfahren Sie unter Freigeben einerAWS Cloud9-Umgebung für ein Projekt-Teammitglied (p. 60).

Informationen zu Teams und Projektrollen finden Sie unter Arbeiten mit AWS CodeStar-Teams (p. 95).

So fügen Sie ein Teammitglied zu einem AWS CodeStar-Projekt (Konsole) hinzu

1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar/.

Wählen Sie das Projekt.2. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.3. Wählen Sie auf der Seite Team members die Option Add team member.4. Führen Sie unter Choose user einen der folgenden Schritte aus:

• Wenn ein IAM-Benutzer für die Person, die Sie hinzufügen möchten, bereits vorhanden ist, wählenSie den IAM-Benutzernamen aus der Liste aus.

Note

Benutzer, die bereits zu einem anderen AWS CodeStar-Projekt hinzugefügt wurden,werden in der Liste AWS CodeStar users from other projects (AWS CodeStar-Benutzer ausanderen Projekten) angezeigt.

Wählen Sie auf der Registerkarte Add team member (Teammitglied hinzufügen) in Project role(Projektrolle) die AWS CodeStar-Rolle (Eigentümer, Beitragender oder Betrachter) für diesenBenutzer aus. Dies ist eine Rolle auf AWS CodeStar-Projektebene, die nur durch einen Eigentümerdes Projekts geändert werden kann. Wenn die Rolle auf einen IAM-Benutzer angewendet wird, stelltsie alle entsprechenden Berechtigungen für den Zugriff auf AWS CodeStar-Projektressourcen bereit.Sie wendet Richtlinien an, die für das Erstellen und Verwalten von Git-Anmeldeinformationen für inCodeCommit gespeicherten Code in IAM an, oder die für das Hochladen von Amazon EC2 SSH-Schlüsseln für den Benutzer in IAM erforderlich sind.

Important

Sie können den Anzeigenamen oder die E-Mail-Informationen für einen IAM-Benutzer nurbereitstellen oder ändern, wenn Sie als dieser Benutzer bei der Konsole angemeldet sind.Weitere Informationen finden Sie unter Verwalten von Anzeigeinformationen für Ihr AWSCodeStar-Benutzerprofil (p. 105).

Wählen Sie Add aus.

16



• Wenn ein IAM-Benutzer für die Person, die Sie dem Projekt hinzufügen möchten, nicht existiert,wählen Sie Create new IAM user (Neuen IAM-Benutzer erstellen). Geben Sie den IAM-Benutzernamen, den AWS CodeStar-Anzeigenamen, die E-Mail-Adresse und die Projektrolle an, dieSie für diesen neuen Benutzer anwenden möchten, und wählen Sie dann Create (Erstellen).

17

AWS CodeStar BenutzerhandbuchSchritt 7: Bereinigen

Sie werden zur IAM-Konsole weitergeleitet, um die Benutzererstellung zu bestätigen. WählenSie Create user (Benutzer erstellen), speichern Sie die Passwortinformationen für diesenneuen Benutzer und klicken Sie dann auf Close (Schließen), um zur AWS CodeStar-Konsolezurückzukehren. Der Benutzer wird mit der von Ihnen gewählten Rolle zum Projekt hinzugefügt.

Note

Für eine einfachere Verwaltung sollte mindestens einem Benutzer die Eigentümer-Rolle fürdas Projekt zugewiesen sein.

5. Senden Sie dem neuen Teammitglied die folgenden Informationen:

• Verbindungsinformationen für Ihr AWS CodeStar-Projekt.• Falls der Quellcode in CodeCommit gespeichert ist, Anweisungen zum Einrichten des Zugriffs mit

Git-Anmeldeinformationen für das CodeCommit-Repository über ihren lokalen Computer.• Informationen darüber, wie Benutzer ihren Anzeigenamen, ihre E-Mail-Adresse und den öffentlichen

Amazon EC2-SSH-Schlüssel verwalten können, finden Sie unter Arbeiten mit Ihrem AWS CodeStar-Benutzerprofil (p. 105).

• Einmaliges Passwort und Verbindungsinformationen, wenn der Benutzer neu bei AWS ist und Sieeinen IAM-Benutzer für diese Person erstellt haben. Das Passwort läuft bei der ersten Anmeldungdes Benutzers ab. Der Benutzer muss ein neues Passwort auswählen.

Schritt 7: BereinigenHerzlichen Glückwunsch! Sie haben das Tutorial abgeschlossen. Wenn Sie dieses Projekt und seineRessourcen nicht weiter verwenden möchten, sollten Sie diese löschen, um laufende Gebühren für IhrAWS-Konto zu vermeiden.

So löschen Sie ein Projekt in AWS CodeStar

1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar/.2. Suchen Sie das Projekt in der Liste und wählen Sie über das Ellipsenmenü (…) Delete (Löschen) aus.

Oder öffnen Sie alternativ das Projekt und wählen Sie im Navigationsbereich Project (Projekt) aus.Wählen Sie auf der Seite mit den Projektdetails Delete project (Projekt löschen) aus.

3. Geben Sie im Feld Type the following project ID to confirm (Geben Sie die folgende Projekt-ID zurBestätigung ein) die Projekt-ID ein und wählen Sie Delete (Löschen) aus.

Das Löschen eines Projekts kann einige Minuten dauern. Wenn das Projekt gelöscht wurde, wird esnicht mehr in der Liste der Projekte in der AWS CodeStar-Konsole angezeigt.

Important

Wenn Sie ein Projekt löschen, werden standardmäßig alle unter Project resources(Projektressourcen) aufgeführten Ressourcen gelöscht. Wenn Sie das Kontrollkästchendeaktivieren, bleiben die Projektressourcen erhalten. Weitere Informationen finden Siehier (p. 93).Wenn Ihr Projekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oder Elemente in Atlassian JIRA), werden diese Ressourcen nicht gelöscht, auchwenn das Kontrollkästchen aktiviert ist.Ihr Projekt kann nicht gelöscht werden, wenn irgendwelche AWS CodeStar verwaltetenRichtlinien manuell mit Rollen verknüpft wurden, die keine IAM-Benutzer sind. Wenn Sie dieverwalteten Richtlinien Ihres Projekts an die Rolle eines verbundenen Benutzers angefügthaben, müssen Sie die Richtlinie trennen, bevor Sie das Projekt löschen können. WeitereInformationen finden Sie unter ??? (p. 140).

18

https://docs.aws.amazon.com/codecommit/latest/userguide/setting-up-gc.html



AWS CodeStar BenutzerhandbuchSchritt 8: Machen Sie Ihr Projekt füreine Produktionsumgebung bereit.

Schritt 8: Machen Sie Ihr Projekt für eineProduktionsumgebung bereit.

Nachdem Sie Ihr Projekt erstellt haben, können Sie Code erstellen, testen und bereitstellen. Lesen Sie diefolgenden Überlegungen zur Pflege Ihres Projekts in einer Produktionsumgebung:

• Wenden Sie regelmäßig Patches an und überprüfen Sie die bewährten Methoden für die Sicherheit dervon Ihrer Anwendung verwendeten Abhängigkeiten. Weitere Informationen finden Sie unter BewährteMethoden für die Sicherheit für AWS CodeStar-Ressourcen (p. 46).

• Überwachen Sie regelmäßig die Umgebungseinstellungen, die von der Programmiersprache für IhrProjekt vorgeschlagen werden.

Nächste SchritteHier sind einige andere Ressourcen, die Ihnen helfen sollen, mehr über AWS CodeStar zu erfahren:

• Das Tutorial: Erstellen und Verwalten einer serverlosen Projekts in AWS CodeStar (p. 19) verwendetein Projekt, das einen Webservice unter Verwendung der Logik in AWS Lambda erstellt und bereitstellt,und der durch eine API in Amazon API Gateway aufgerufen werden kann.

• AWS CodeStar-Projektvorlagen (p. 41) beschreibt weitere Projekttypen, die Sie erstellen können.• Anpassen eines AWS CodeStar-Dashboards (p. 67) bietet weitere Informationen über die Anpassung

der Dashboards von Projekten, die Integration in JIRA und vieles andere mehr.• Arbeiten mit AWS CodeStar-Teams (p. 95) bietet Informationen darüber, wie Sie andere aktivieren,

um mit Ihnen an Ihren Projekten zu arbeiten.

Tutorial: Erstellen und Verwalten einer serverlosenProjekts in AWS CodeStar

In diesem Tutorial verwenden Sie AWS CodeStar, um ein Projekt zu erstellen, das das AWS ServerlessApplication Model (AWS-SAM) zum Erstellen und Verwalten von AWS-Ressourcen für einen in AWSLambda gehosteten Web-Service.

AWS CodeStar verwendet AWS SAM, das auf AWS CloudFormation basiert, um eine vereinfachteMethode für das Erstellen und Verwalten von unterstützten AWS-Ressourcen bereitzustellen, einschließlichvon Amazon API Gateway-APIs, AWS Lambda-Funktionen und Amazon DynamoDB-Tabellen. (DiesesProjekt verwendet keine Amazon DynamoDB-Tabellen.)

Weitere Informationen finden Sie unter AWS Serverless Application Model (AWS SAM) auf GitHub.

Voraussetzung: Durchführung der Schritte in Einrichten von AWS CodeStar (p. 3).

Note

Für Ihr AWS-Konto fallen möglicherweise Kosten im Zusammenhang mit diesem Tutorial an,einschließlich der Kosten für AWS-Services, die von AWS CodeStar verwendet werden. WeitereInformationen finden Sie unter AWS CodeStar-Preise.

Themen• Übersicht (p. 20)

19

https://github.com/awslabs/serverless-application-model

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

AWS CodeStar BenutzerhandbuchÜbersicht

• Schritt 1: Erstellen des Projekts (p. 20)• Schritt 2: Entdecken Sie die Projekt-Ressourcen (p. 21)• Schritt 3: Testen des Webservice (p. 24)• Schritt 4: Einrichten Ihrer lokalen Workstation zur Bearbeitung des Projektcodes (p. 25)• Schritt 5: Dem Webservice Logik hinzufügen (p. 26)• Schritt 6: Testen des erweiterten Webservice (p. 27)• Schritt 7: Hinzufügen eines Einheitentests für den Webservice (p. 28)• Schritt 8: Anzeigen der Ergebnisse des Einheitentests (p. 30)• Schritt 9: Bereinigen (p. 30)• Nächste Schritte (p. 31)

ÜbersichtIn diesem Tutorial werden Sie die folgenden Aktivitäten durchführen:

1. Verwenden von AWS CodeStar zum Erstellen eines Projekts, das AWS SAM verwendet, um einenauf Python basierenden Webservice zu erstellen und bereitzustellen. Dieser Webservice wird in AWSLambda gehostet, der Zugriff kann über Amazon API Gateway erfolgen.

2. Entdecken Sie die wichtigsten Ressourcen des Projekts, unter anderem:• Das AWS CodeCommit-Repository, in dem der Quellcode des Projekts gespeichert ist. Dieser

Quellcode beinhaltet die Logik des Webservice und definiert die zugehörigen AWS-Ressourcen.• Die AWS CodePipeline-Pipeline, die die Erstellung des Quellcodes automatisiert. Diese Pipeline

verwendet AWS SAM zum Erstellen und Bereitstellen einer Funktion für AWS Lambda, zum Erstelleneiner zugehörigen API in Amazon API Gateway und für die Verbindung der API mit der Funktion.

• Die Funktion, die AWS Lambda bereitgestellt wird.• Die API, die in Amazon API Gateway erstellt wird.

3. Testen Sie den Webservice, um zu bestätigen, dass AWS CodeStar den Webservice wie erwarteteerstellt und bereitgestellt hat.

4. Richten Sie Ihre lokalen Workstation so ein, dass sie mit dem Quellcode Ihres Projekts zurechtkommt.5. Ändern Sie den Quellcode Ihres Projekts unter Verwendung Ihrer lokalen Workstation. Wenn Sie dem

Projekt eine Funktion hinzufügen und dann Ihre Änderungen im Quellcode speichern, erstellt AWSCodeStar den Webservice neu und stellt ihn bereit.

6. Testen Sie den Webservice erneut, um zu bestätigen, dass AWS CodeStar den Webservice wieerwartete neu erstellt und bereitgestellt hat.

7. Schreiben Sie unter Verwendung der lokalen Arbeitsstation einen Einheitentest, um einen Teil Ihrermanueller Tests durch einen automatisierten Test zu ersetzen. Wenn Sie den Komponententestverschieben, baut AWS CodeStar den Webservice neu auf und installiert ihn neu und führt denKomponententest durch.

8. Zeigen Sie die Ergebnisse der Einheitentests an.9. Bereinigen Sie das Projekt. Dieser Schritt hilft Ihnen, Kosten für Ihr AWS-Konto zu vermeiden, die mit

diesem Tutorial zusammenhängen.

Schritt 1: Erstellen des ProjektsIn diesem Schritt erstellen Sie mithilfe der AWS CodeStar-Konsole ein Projekt.

1. Melden Sie sich an der AWS Management Console an und öffnen Sie die AWS CodeStar-Konsoleunter https://console.aws.amazon.com/codestar/.

20


AWS CodeStar BenutzerhandbuchSchritt 2: Entdecken Sie die Projekt-Ressourcen

Note

Sie müssen sich bei der AWS Management Console unter Verwendung derAnmeldeinformationen des IAM-Benutzers anmelden, den Sie in Einrichten von AWSCodeStar (p. 3) erstellt oder identifiziert haben. Diesem Benutzer muss die verwalteteAWSCodeStarFullAccess-Richtlinie angefügt sein.

2. Wählen Sie die AWS-Region, in der Sie das Projekt und seine Ressourcen erstellen möchten.

Informationen über die AWS-Regionen, in denen AWS CodeStar verfügbar ist, finden Sie unterRegionen und Endpunkte in der Allgemeinen AWS-Referenz.

3. Wählen Sie Create a new project (Neues Projekt erstellen). Falls Create a new project nicht angezeigtwird, wählen Sie Start a new project (Neues Projekt starten).

4. Auf der Seite Choose a project template (Auswählen einer Projektvorlage):

• Für Application category (Anwendungskategorie) wählen Sie Web service (Webservice).• Für Programming languages (Programmiersprachen) wählen Sie Python.• Für AWS services (Services), wählen Sie AWS Lambda.

5. Wählen Sie das Feld mit den von Ihnen gewählten Optionen.6. Geben Sie für Project name (Projektname) einen Namen für Ihr Projekt ein (z. B.: My SAM Project).

Wenn Sie einen anderen Namen als im Beispiel gezeigt verwenden, müssen Sie diesen durchgehendim ganzen Tutorial verwenden.

Für Project ID (Projekt-ID) wählt AWS CodeStar eine zugehörige ID für dieses Projekt aus (z. B.:my-sam-project). Wenn Sie eine andere Projekt-ID sehen, müssen Sie diese im gesamten Tutorialverwenden.

Behalten Sie die Auswahl von AWS CodeCommit bei und ändern Sie den Wert für Repository name(Repository-Name) nicht.

7. Wählen Sie Next.8. Lassen Sie AWS CodeStar would like permission to administer AWS resources on your behalf (AWS

CodeStar möchte die Berechtigung, AWS-Ressourcen in Ihrem Namen zu verwalten) ausgewählt, undwählen Sie dann Create Project (Projekt erstellen).

Wenn Sie zum ersten Mal mit AWS CodeStar in dieser AWS-Region arbeiten, geben Sie für DisplayName und Email den Anzeigenamen und die E-Mail-Adresse an, die AWS CodeStar für Ihren IAM-Benutzer verwenden soll. Wählen Sie Next.

9. Wählen Sie für Choose how you want to edit your project code (Wählen Sie aus, wie Sie IhrenProjektcode bearbeiten möchten) die Option Skip (Überspringen). Ihre lokale Arbeitsstation zurBearbeitung des Projektcodes richten Sie in einem späteren Schritt ein.

10. Warten Sie, bis AWS CodeStar das Projekt erstellt hat. Dies kann einige Minuten dauern. Fahren Sienicht fort, bevor Sie nicht Welcome to My SAM Project! (Willkommen bei My SAM Project!) sehen.

Schritt 2: Entdecken Sie die Projekt-RessourcenIn diesem Schritt erkunden Sie vier der AWS-Ressourcen des Projekts, um zu verstehen, wie das Projektfunktioniert:

• Das AWS CodeCommit-Repository, in dem der Quellcode des Projekts gespeichert ist. AWS CodeStargibt dem Repository den Namen my-sam-project, wobei my-sam-project der Name des Projekts ist.

• Die AWS CodePipeline-Pipeline, die CodeBuild und AWS SAM verwendet, um die Erstellung undBereitstellung der Lambda-Funktion und API in API Gateway des Web-Services zu automatisieren.AWS CodeStar gibt der Pipeline den Namen my-sam-project--Pipeline, wobei my-sam-project die ID desProjekts ist.

21



• Die Lambda-Funktion, die die Logik des Webservice enthält. AWS CodeStar gibt der Funktion denNamen awscodestar-my-sam-project-lambda-HelloWorld-RANDOM_ID, wobei gilt:• my-sam-project ist die ID des Projekts.• HelloWorld ist die Funktions-ID, wie in der Datei template.yaml im AWS CodeCommit-Repository

angegeben. Diese Datei erkunden Sie später.• RANDOM_ID ist eine zufällige ID, die AWS SAM der Funktion zuordnet, um Eindeutigkeit

sicherzustellen.• Die API in API Gateway, mit dem Sie einfacher die Lambda-Funktion aufrufen können. AWS CodeStar

gibt der API den Namen awscodestar-my-sam – lambda, wobei my-sam-project die ID des Projekts ist.

Das Quellcode-Repository in CodeCommit kennenlernen

1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im seitlichen NavigationsfensterCode.

2. In der CodeCommit-Konsole auf der Seite Code werden die Quellcodedateien für das Projektangezeigt:

• buildspec.yml, die CodeBuild nach Anweisung von CodePipeline in der Erstellungsphaseverwenden soll, um den Webservice mit AWS SAM zu packen.

• index.py, die die Logik für die Lambda-Funktion enthält. Diese Funktion gibt einfach dieZeichenfolge Hello World und den Zeitstempel im ISO-Format aus.

• README.md, die allgemeine Informationen über das Repository enthält.• template-configuation.json, die den Projekt-ARN mit Platzhaltern enthält, die zum Markieren

von Ressourcen mit der Projekt-ID verwendet werden• template.yml, die AWS SAM verwendet, um den Webservice zu packen und die API in API

Gateway zu erstellen.

22


Um den Inhalt einer Datei anzuzeigen, wählen Sie sie in der Liste aus.

Weitere Informationen zur Verwendung der CodeCommit-Konsole finden Sie unter AWS CodeCommit-Benutzerhandbuch.

Die Pipeline in CodePipeline erkunden

1. Um Informationen über die Pipeline anzuzeigen, wählen Sie bei geöffnetem Projekt in der AWSCodeStar-Konsole die Option Dashboard aus. Auf der Kachel Continuous deployment (DurchgehendeBereitstellung) sehen Sie, dass die Pipeline Folgendes enthält:

• Eine Source-Phase, um den Quellcode aus CodeCommit abzurufen.• Eine Build-Phase, um den Quellcode mit CodeBuild zu erstellen.• Eine Deploy-Phase, um den erstellten Quellcode und die AWS-Ressourcen mit AWS SAM

bereitzustellen.

23

https://docs.aws.amazon.com/codecommit/latest/userguide/

https://docs.aws.amazon.com/codecommit/latest/userguide/

AWS CodeStar BenutzerhandbuchSchritt 3: Testen des Webservice

2. Um weiter Informationen über die Pipeline auf der Kachel Continuous deployment (DurchgehendeBereitstellung) anzuzeigen, wählen Sie den Link CodePipeline details in der seitlichenNavigationsleiste, und wählen Pipeline, um die Pipeline in der CodePipeline-Konsole zu öffnen.

Weitere Informationen zur Verwendung der CodePipeline-Konsole finden Sie unter AWS CodePipeline-Benutzerhandbuch.

So erkunden Sie die AWS-Service-Ressourcen auf der Projektseite

1. Öffnen Sie Ihr Projekt in der AWS CodeStar-Konsole und wählen Sie im seitlichen NavigationsfensterProject (Projekt).

2. Überprüfen Sie die Listen Projektdetails und Projektressourcen.

Erkunden der Funktion in Lambda

1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im seitlichen NavigationsfensterProject (Projekt).

2. Wählen Sie in der Liste Project Resources (Projektressourcen) den Link in der Spalte ARN für dieLambda-Funktion aus.

Der Code der Funktion wird in der Lambda-Konsole angezeigt.

Weitere Informationen zur Verwendung der Lambda-Konsole finden Sie unter AWS Lambda DeveloperGuide.

Erkunden der API in API Gateway


2. Wählen Sie in der Liste Project Resources (Projektressourcen) den Link in der Spalte ARN für dieAmazon API Gateway-API aus.

Die Ressourcen für die API werden in der API Gateway-Konsole angezeigt.

Weitere Informationen zur Verwendung der API Gateway-Konsole finden Sie unter API Gateway-Entwicklerhandbuch.

Schritt 3: Testen des WebserviceIn diesem Schritt testen Sie den Webservice, den AWS CodeStar gerade erstellt und bereitgestellt hat.

1. Während Ihr Projekt noch aus dem vorherigen Schritt geöffnet ist, wählen Sie in der seitlichenNavigationsleiste Dashboard.

2. Stellen Sie sicher, dass auf der Kachel Continuous deployment (Durchgehende Bereitstellung) dieInformation Succeeded (Erfolgreich) für die Phasen Source, Build und Deploy angezeigt wird, bevorSie fortfahren. Dies kann einige Minuten dauern.

Note

Wird für eine der Phasen Failed (Fehlgeschlagen) angezeigt, kann Ihnen Folgendes bei derFehlersuche helfen:


24

https://docs.aws.amazon.com/codepipeline/latest/userguide/

https://docs.aws.amazon.com/codepipeline/latest/userguide/

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

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

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

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



AWS CodeStar BenutzerhandbuchSchritt 4: Einrichten Ihrer lokalen Workstation

zur Bearbeitung des Projektcodes




3. Wählen Sie den Link auf der Kachel Application endpoints (Anwendungsendpunkte). Es sollte wie folgtaussehen: https://API_ID.execute-api.REGION_ID.amazonaws.com/Prod/, wobei:

• API_ID steht für die ID, die API Gateway der API zugewiesen hat.• REGION_ID ist die ID der zugehörigen AWS-Region.• Prod ist der Name der zugehörigen API-Bereitstellungsphase in API Gateway.

Auf der neuen Registerkarte, die in Ihrem Webbrowser geöffnet wird, zeigt der Webservice die folgendeAusgabe als Antwort an:

{"output": "Hello World", "timestamp": "2017-08-30T15:53:42.682839"}

Schritt 4: Einrichten Ihrer lokalen Workstation zurBearbeitung des ProjektcodesIn diesem Schritt richten Sie Ihre lokale Arbeitsstation zur Bearbeitung des Quellcodes im AWS CodeStar-Projekt ein. Bei Ihrer lokalen Workstation kann es sich um einen physischen oder virtuellen Computer untermacOS, Windows oder Linux handeln.

1. Während Ihr Projekt noch aus dem vorherigen Schritt geöffnet ist:

• Wählen Sie im seitlichen Navigationsbereich Project (Projekt), und klicken Sie dann auf dieSchaltfläche Connect tools (Tools verbinden).

• Wählen Sie die Kachel Command line tools (Befehlszeilen-Tools).

Wenn Sie Visual Studio oder Eclipse installiert haben, wählen Sie stattdessen die Kachel VisualStudio oder Eclipse, folgen Sie den Anweisungen und fahren Sie fort mit Schritt 5: Dem WebserviceLogik hinzufügen (p. 26).

• Wählen Sie unter Clone repository URL (Repository-URL klonen) HTTPS aus.Note

Wir empfehlen, HTTPS statt SSH zu wählen, weil HTTPS einfacher einzurichten ist. WennSie SSH verwenden müssen, wählen Sie SSH, folgen den Anweisungen und fahren dannmit Schritt 5: Dem Webservice Logik hinzufügen (p. 26) fort.

• Wählen Sie See instructions (Anweisungen anzeigen) aus.2. Wählen Sie auf der Seite Connect to your tools (Mit Ihren Tools verbinden) für Operating System

(Betriebssystem) das auf Ihrer Workstation ausgeführte Betriebssystem.3. Folgen Sie den Anweisungen, um die folgenden Aufgaben auszuführen:

a. Einrichtung von Git auf Ihrer lokalen Workstation.b. Verwenden Sie die IAM-Konsole, um Git-Anmeldeinformationen für Ihren IAM-Benutzer zu

generieren.

25




AWS CodeStar BenutzerhandbuchSchritt 5: Dem Webservice Logik hinzufügen

c. Klonen Sie das CodeCommit-Repository Ihres Projekts auf Ihre lokale Workstation.4. Wählen Sie im linken Navigationsbereich Dashboard aus, um zum Projekt-Dashboard zurückzukehren.

Schritt 5: Dem Webservice Logik hinzufügenIn diesem Schritt verwenden Sie Ihre lokalen Workstation, um dem Webservice Logik hinzuzufügen.Insbesondere fügen Sie eine Lambda-Funktion hinzu und verbinden sie dann mit der API in API Gateway.

1. Gehen Sie auf Ihrer lokalen Workstation zu dem Verzeichnis, das das geklonte Quellcode-Repositoryenthält.

2. Erstellen Sie in diesem Verzeichnis eine Datei namens hello.py. Fügen Sie den folgenden Codehinzu und speichern Sie dann die Datei:

import json

def handler(event, context): data = { 'output': 'Hello ' + event["pathParameters"]["name"] } return {'statusCode': 200, 'body': json.dumps(data), 'headers': {'Content-Type': 'application/json'}}

Der oben gezeigte Code gibt einfach die Zeichenfolge Hello und die Zeichenfolge aus, die derAufrufer an die Funktion sendet.

3. Im selben Verzeichnis öffnen Sie die Datei template.yml. Fügen Sie am Ende der Datei denfolgenden Code hinzu und speichern Sie dann die Datei:

Hello: Type: AWS::Serverless::Function Properties: Handler: hello.handler Runtime: python3.7 Role: Fn::GetAtt: - LambdaExecutionRole - Arn Events: GetEvent: Type: Api Properties: Path: /hello/{name} Method: get

AWS SAM verwendet diesen Code, um eine Funktion in Lambda zu erstellen, eine neue Methode undeinen Pfad für die API in API Gateway hinzuzufügen, und dann diese Methode und den Pfad mit derneuen Funktion zu verbinden.

Note

Die Einrückung des obigen Codes ist wichtig. Wenn Sie den Code nicht genau so wie gezeigthinzufügen, wird das Projekt möglicherweise nicht korrekt erstellt.

4. Führen Sie den Befehl git add . aus, um Ihre Dateiänderungen dem Staging-Bereich des geklontenRepositorys hinzuzufügen. Vergessen Sie nicht den Punkt (.), der dafür sorgt, dass alle geändertenDateien hinzugefügt werden.

26

AWS CodeStar BenutzerhandbuchSchritt 6: Testen des erweiterten Webservice

Note

Wenn Sie Visual Studio oder Eclipse anstelle der Befehlszeile verwenden, können sich dieAnweisungen für die Nutzung von Git unterscheiden. Weitere Informationen finden Sie in derVisual Studio- oder Eclipse-Dokumentation.

5. Führen Sie den Befehl git commit -m "Added hello.py and updated template.yaml." aus, um Ihrebereitgestellten Dateien in das geklonte Repository zu übertragen

6. Führen Sie den Befehl git push aus, um Ihr Commit in das Remote-Repository zu verschieben.

Note

Möglicherweise werden Sie aufgefordert, den Benutzernamen und das Passwort einzugeben,das IAM für Sie generiert hat. Um zu vermeiden, dass Sie bei jeder Interaktion mit demRemote-Repository dazu aufgefordert werden, sollten Sie einen Git Credential Managerinstallieren und konfigurieren. Unter macOS oder Linux beispielsweise können Sie git configcredential.helper 'cache --timeout 900' auf dem Terminal ausführen, um höchstens alle 15Minuten zur Eingabe aufgefordert zu werden. Alternativ können Sie git config credential.helper'store --file ~/.git-credentials' ausführen, um nie wieder aufgefordert zu werden. GIT speichertIhre Anmeldeinformationen in einer Klartextdatei in Ihrem Stammverzeichnis. WeitereInformationen finden Sie unter Git Tools - Credential Storage auf der Git-Website.

Nachdem AWS CodeStar den Push erkannt hat, weist es CodePipeline an, mit CodeBuild und AWS SAMden Webservice automatisch neu zu erstellen und bereitzustellen. Sie können den Bereitstellungsfortschrittim Projekt-Dashboard verfolgen.

AWS SAM gibt der Funktion den Namen awscodestar-my-sam-project-lambda-Hello-RANDOM_ID, wobeigilt:

• my-sam-project ist die ID des Projekts.• Hallo ist die Funktions-ID, wie in der Datei template.yaml angegeben.• RANDOM_ID ist eine zufällige ID, die AWS SAM der Funktion zuordnet, um Eindeutigkeit sicherzustellen.

Schritt 6: Testen des erweiterten WebserviceIn diesem Schritt testen Sie den erweiterten Webservice, den AWS CodeStar basierend auf der Logikerstellt und bereitgestellt hat, die Sie im vorherigen Schritt hinzugefügt haben.

1. Wählen Sie bei noch geöffnetem Projekt in der AWS CodeStar-Konsole im seitlichenNavigationsfenster Dashboard.

2. Stellen Sie sicher, dass auf der Kachel Continuous deployment (Durchgehende Bereitstellung) diePipeline erneut ausgeführt wurde, und dass die Information Succeeded (Erfolgreich) für die PhasenSource, Build und Deploy angezeigt wird, bevor Sie fortfahren. Dies kann einige Minuten dauern.

Note

Wird für eine der Phasen Failed (Fehlgeschlagen) angezeigt, kann Ihnen Folgendes bei derFehlersuche helfen:



27

https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage





AWS CodeStar BenutzerhandbuchSchritt 7: Hinzufügen eines

Einheitentests für den Webservice



3. Wählen Sie den Link auf der Kachel Application endpoints (Anwendungsendpunkte). Es sollte wie folgtaussehen: https://API_ID.execute-api.REGION_ID.amazonaws.com/Prod/, wobei:

• API_ID steht für die ID, die API Gateway der API zugewiesen hat.• REGION_ID ist die ID der zugehörigen AWS-Region.• Prod ist der Name der zugehörigen API-Bereitstellungsphase in API Gateway.

Auf der neuen Registerkarte, die in Ihrem Webbrowser geöffnet wird, zeigt der Webservice diefolgende Ausgabe als Antwort an:

{"output": "Hello World", "timestamp": "2017-08-30T15:53:42.682839"}

4. Fügen Sie im Adressfeld der Registerkarte den Pfad /hello/ und Ihren Vornamen am Ende der URLein (z. B. https://API-ID.execute-api.REGIONS-ID.amazonaws.com/Prod/hello/IHR_VORNAME) unddrücken Sie dann die Eingabetaste.

Wenn Ihr Vorname Mary ist, zeigt der Webservice die folgenden Antwort als Ausgabe an:

{"output": "Hello Mary"}

Schritt 7: Hinzufügen eines Einheitentests für denWebserviceIn diesem Schritt verwenden Sie Ihre lokale Workstation, um einen Test hinzuzufügen, den AWS CodeStarauf dem Webservice ausführt. Dieser Test ersetzt die manuellen Tests, die Sie zuvor ausgeführt haben.

1. Gehen Sie auf Ihrer lokalen Workstation zu dem Verzeichnis, das das geklonte Quellcode-Repositoryenthält.

2. Erstellen Sie in diesem Verzeichnis eine Datei namens hello_test.py. Fügen Sie den folgendenCode hinzu und speichern Sie dann die Datei.

from hello import handler

def test_hello_handler():

event = { 'pathParameters': { 'name': 'testname' } }

context = {}

expected = { 'body': '{"output": "Hello testname"}', 'headers': { 'Content-Type': 'application/json'

28


AWS CodeStar BenutzerhandbuchSchritt 7: Hinzufügen eines

Einheitentests für den Webservice

}, 'statusCode': 200 }

assert handler(event, context) == expected

Dieser Test prüft, ob die Ausgabe der Lambda-Funktion das erwartete Format aufweist. Ist dies derFall, ist der Test erfolgreich. Andernfalls schlägt der Test fehl.

3. Im selben Verzeichnis öffnen Sie die Datei buildspec.yml. Ersetzen Sie den Dateiinhalt durch denfolgenden Code und speichern Sie dann die Datei.

version: 0.2

phases: install: runtime-versions: python: 3.7

commands: - pip install pytest # Upgrade AWS CLI to the latest version - pip install --upgrade awscli

pre_build: commands: - pytest

build: commands: # Use AWS SAM to package the application by using AWS CloudFormation - aws cloudformation package --template template.yml --s3-bucket $S3_BUCKET --output-template template-export.yml

# Do not remove this statement. This command is required for AWS CodeStar projects. # Update the AWS Partition, AWS Region, account ID and project ID in the project ARN on template-configuration.json file so AWS CloudFormation can tag project resources. - sed -i.bak 's/\$PARTITION\$/'${PARTITION}'/g;s/\$AWS_REGION\$/'${AWS_REGION}'/g;s/\$ACCOUNT_ID\$/'${ACCOUNT_ID}'/g;s/\$PROJECT_ID\$/'${PROJECT_ID}'/g' template-configuration.json

artifacts: type: zip files: - template-export.yml - template-configuration.json

Diese Build-Spezifikation weist CodeBuild an, pytest in seiner Build-Umgebung zu installieren, dasPython-Test-Framework. CodeBuild verwendet pytest, um den Komponententest auszuführen. Dieweiteren Build-Spezifikation bleiben unverändert.

4. Verwenden Sie Git, um diese Änderungen im Remote-Repository zu speichern.

git add .

git commit -m "Added hello_test.py and updated buildspec.yml."

git push

29

AWS CodeStar BenutzerhandbuchSchritt 8: Anzeigen der Ergebnisse des Einheitentests

Schritt 8: Anzeigen der Ergebnisse des EinheitentestsIn diesem erfahren Sie, ob der Einheitentest erfolgreich war oder fehlgeschlagen ist.

1. Wählen Sie bei noch geöffnetem Projekt in der AWS CodeStar-Konsole im seitlichenNavigationsfenster Dashboard.

2. Stellen Sie auf der Kachel Continuous Deployment (Durchgehende Bereitstellung) sicher, dass diePipeline erneut ausgeführt wurde, bevor Sie fortfahren. Dies kann einige Minuten dauern.

Wenn der Einheitentest erfolgreich war, wird Succeeded (Erfolgreich) für die Build-Phase angezeigt.3. Um das detaillierte Ergebnis des Einheitentests anzuzeigen, wählen Sie auf der Kachel Continuous

deployment (Durchgehende Bereitstellung) den Link CodeBuild in der Build-Phase aus.4. Wählen Sie in der CodeBuild-Konsole auf der Seite Build Project: my-sam-project (Projekt erstellen) in

Build history (Build-Verlauf) den Link in der Spalte Build run (Build-Lauf) der Tabelle aus.5. Wählen Sie auf der Seite my-sam-project:BUILD_ID in Build logs (Protokolle erstellen) den Link View

entire log (Gesamtes Protokoll anzeigen).6. Suchen Sie in der Amazon CloudWatch Logs-Konsole nach einer Protokollausgabe für ein

Testergebnis, das etwa wie folgt aussieht. Das folgende Testergebnis zeigt, dass der Test bestandenwurde:

...============================= test session starts ==============================platform linux2 -- Python 2.7.12, pytest-3.2.1, py-1.4.34, pluggy-0.4.0rootdir: /codebuild/output/src123456789/src, inifile:collected 1 item

hello_test.py .

=========================== 1 passed in 0.01 seconds ===========================...

Ist der Test fehlgeschlagen, sollten in der Protokollausgabe detaillierte Informationen enthalten sind,die Ihnen bei der Fehlersuche helfen.

Schritt 9: BereinigenIn diesem Schritt bereinigen Sie das Projekt, um zu verhindern, dass laufende Gebühren für das Projekt inRechnung gestellt werden.

Wenn Sie dieses Projekt weiter verwenden möchten, können Sie diesen Schritt überspringen, dann werdenIhrem AWS-Konto jedoch weiter Gebühren in Rechnung gestellt.


2. Wählen Sie Delete project (Projekt löschen).3. Geben Sie den Namen des Projekts ein, behalten Sie die Markierung im Kontrollkästchen Delete

associated resources along with AWS CodeStar project (Löschen Sie zugeordnete Ressourcenzusammen mit dem AWS CodeStar-Projekt) bei, und wählen Sie dann Delete (Löschen).

Important

Wenn Sie dieses Kontrollkästchen deaktivieren, wird der Projektdatensatz von AWS CodeStargelöscht, aber viele der AWS-Ressourcen des Projekts bleiben erhalten. Ihr AWS-Kontokönnte weiterhin belastet werden.

30

AWS CodeStar BenutzerhandbuchNächste Schritte

Wenn es noch einen Amazon S3-Bucket gibt, den AWS CodeStar für dieses Projekt erstellt hat, führen Siediese Schritte aus, um ihn zu löschen:

1. Öffnen Sie die CodeCommit-Konsole unter https://console.aws.amazon.com/s3/.2. Wählen Sie in der Bucket-Liste das Symbol neben aws-codestar-REGION_ID-ACCOUNT_ID-my-sam-

project--pipe, wobei gilt:

• REGION_ID ist die ID der AWS-Region für das Projekt, das Sie gerade gelöscht haben.• ACCOUNT_ID ist Ihre AWS-Konto-ID.• my-sam-project ist die ID des Projekts, das Sie gerade gelöscht haben.

3. Wählen Sie Empty Bucket (Leerer Bucket). Geben Sie den Namen des Buckets ein und klicken Siedann auf Confirm (Bestätigen).

4. Wählen Sie Delete Bucket (Bucket löschen). Geben Sie den Namen des Buckets ein und klicken Siedann auf Confirm (Bestätigen).

Nächste SchritteNachdem Sie dieses Tutorial abgeschlossen haben, empfehlen wir Ihnen, die folgenden Ressourcen zuüberprüfen:

• Die Erste Schritte mit AWS CodeStar (p. 6) Anleitung verwendet ein Projekt, das eine auf Node.jsbasierende Webanwendung, die auf einer Amazon EC2-Instanz ausgeführt wird, erstellt und bereitstellt.

• AWS CodeStar-Projektvorlagen (p. 41) beschreibt weitere Projekttypen, die Sie erstellen können.• Anpassen eines AWS CodeStar-Dashboards (p. 67) zeigt, wie Sie die Dashboards Ihres Projekts

anzeigen, eine Integration mit JIRA einrichten, und vieles andere mehr.• Arbeiten mit AWS CodeStar-Teams (p. 95) zeigt, wie Ihnen andere bei Ihren Projekten helfen können.

Tutorial: Erstellen eines Projekts in AWS CodeStarmit der AWS CLI

Dieses Tutorial zeigt Ihnen, wie Sie mit AWS CLI ein AWS CodeStar-Projekt mit Beispiel-Quellcode undeiner Beispiel-Toolchain-Vorlage erstellen können. AWS CodeStar stellt die AWS-Infrastruktur und IAM-Ressourcen bereit, die in einer AWS CloudFormation-Toolchain-Vorlage angegeben sind. Das Projektverwaltet Ihre Toolchain-Ressourcen für die Erstellung und Bereitstellung Ihres Quellcodes.

AWS CodeStar verwendet AWS CloudFormation zum Erstellen und Bereitstellen Ihres Beispielcodes.Dieser Beispielcode erstellt einen Webservice, der in AWS Lambda gehostet wird und über Amazon APIGateway erreichbar ist.

Voraussetzungen:

• Führen Sie die Schritte unter Einrichten von AWS CodeStar (p. 3) aus.• Sie müssen einen Amazon S3-Speicher-Bucket angelegt haben. In diesem Tutorial laden Sie den

exemplarischen Quellcode und die Toolchain-Vorlage an diese Stelle hoch.

Note

Für Ihr AWS-Konto fallen möglicherweise Kosten im Zusammenhang mit diesem Tutorial an, auchfür die AWS-Services, die von AWS CodeStar verwendet werden. Weitere Informationen findenSie unter AWS CodeStar-Preise.

31

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

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

AWS CodeStar BenutzerhandbuchSchritt 1: Laden Sie den exemplarischen

Quellcode herunter und überprüfen Sie ihn.

Themen• Schritt 1: Laden Sie den exemplarischen Quellcode herunter und überprüfen Sie ihn. (p. 32)• Schritt 2: Laden Sie die Beispiel-Toolchain-Vorlage herunter (p. 32)• Schritt 3: Testen Sie Ihre Toolchain-Vorlage in AWS CloudFormation (p. 33)• Schritt 4: Laden Sie Ihren Quellcode und Ihre Toolchain-Vorlage hoch (p. 34)• Schritt 5: Erstellen eines Projekts in AWS CodeStar (p. 35)

Schritt 1: Laden Sie den exemplarischen Quellcodeherunter und überprüfen Sie ihn.Für dieses Tutorial steht eine Zip-Datei zum Download zur Verfügung. Es enthält den Beispiel-Quellcodefür eine Node.js Beispielanwendung auf der Lambda-Datenverarbeitungsplattform. Wenn der Quellcode inIhrem Repository platziert ist, werden dessen Ordner und Dateien wie abgebildet angezeigt:

tests/app.jsbuildspec.ymlindex.jspackage.jsonREADME.mdtemplate.yml

Die folgenden Projektelemente sind in Ihrem exemplarischen Quellcode dargestellt:

• tests/: Komponententests, die für dieses CodeBuild-Projekt eingerichtet wurden. Dieser Ordner ist imBeispielcode enthalten, er ist zum Erstellen eines Projekts aber nicht erforderlich.

• app.js: Anwendungsquellcode für Ihr Projekt.• buildspec.yml: Die Build-Anweisungen für Ihre Build-Stufe der CodeBuild-Ressource. Diese Datei

wird für eine Toolchain-Vorlage mit einer CodeBuild-Ressource benötigt.• package.json: Die Abhängigkeitsinformationen für Ihren Anwendungsquellcode.• README.md: Die Projekt-Readme-Datei, die in allen AWS CodeStar-Projekten enthalten ist. Diese Datei

ist im Beispielcode enthalten, sie ist zum Erstellen eines Projekts aber nicht erforderlich.• template.yml: Die Infrastrukturvorlagendatei oder SAM-Vorlagendatei, die in allen AWS CodeStar-

Projekten enthalten ist. Dies unterscheidet sich von der Toolchain template.yml, die Sie später in diesemTutorial hochladen. Diese Datei ist im Beispielcode enthalten, sie ist zum Erstellen eines Projekts abernicht erforderlich.

Schritt 2: Laden Sie die Beispiel-Toolchain-VorlageherunterDie für dieses Tutorial bereitgestellte beispielhafte Toolchain-Vorlage erstellt ein Repository (CodeCommit),eine Pipeline (CodePipeline) und einen Build-Container (CodeBuild) und verwendet AWS CloudFormation,um Ihren Quellcode auf einer Lambda-Plattform bereitzustellen. Zusätzlich zu diesen Ressourcen gibt esauch IAM-Rollen, mit denen Sie die Berechtigungen Ihrer Laufzeitumgebung überprüfen können, einenAmazon S3-Bucket, in dem CodePipeline Ihre Bereitstellungsartefakte speichert, und eine CloudWatch-Ereignisse-Regel, die zum Auslösen von Pipeline-Bereitstellungen verwendet wird, wenn Sie Code in IhrRepository verschieben. Um mit den Bewährten AWS IAM Methoden übereinzustimmen, reduzieren Sie dieReichweite der Richtlinien Ihrer Toolchain-Rollen, wie sie in diesem Beispiel definiert sind.

Laden Sie die AWS CloudFormation-Mustervorlage herunter und entpacken Sie sie in das YAML Format.

32

samples/nodews.zip

https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege

samples/toolchain.zip

AWS CodeStar BenutzerhandbuchSchritt 3: Testen Sie Ihre Toolchain-

Vorlage in AWS CloudFormation

Wenn Sie den create-project-Befehl zu einem späteren Zeitpunkt in diesem Tutorial ausführen, erstelltdiese Vorlage die folgenden benutzerdefinierten Toolchain-Ressourcen in AWS CloudFormation. WeitereInformationen zu den in diesem Tutorial erstellten Ressourcen finden Sie in den folgenden Themen imAWS CloudFormation Benutzerhandbuch:

• Die AWS CloudFormation-Ressource AWS:: CodeCommit:: Repository erstellt ein CodeCommit-Repository.

• Die AWS CloudFormation-Ressource AWS:: CodeBuild:: Project erstellt ein CodeBuild-Build-Projekt.• Die AWS CloudFormation-Ressource AWS:: CodeDeploy:: Application erstellt eine CodeDeploy-

Anwendung.• Die AWS CloudFormation-Ressource AWS:: CodePipeline:: Pipeline erstellt eine CodePipeline-Pipeline.• Die AWS CloudFormation-Ressource AWS:: S3:: Bucket erstellt Ihr Pipeline-Artefakt-Bucket.• Die AWS CloudFormation-Ressource AWS:: S3:: BucketPolicy erstellt die Artifact-Bucket-Richtlinie für Ihr

Pipeline-Artefakt-Bucket.• Die AWS CloudFormation-Ressource AWS:: IAM:: Role erstellt die CodeBuild-IAM-Auftragnehmer-Rolle,

die AWS CodeStar-Berechtigungen zur Verwaltung Ihres CodeBuild-Build-Projekts erteilt.• Die AWS CloudFormation-Ressource AWS:: IAM:: Role erstellt die CodePipeline-IAM-Auftragnehmer-

Rolle, die AWS CodeStar Berechtigungen erteilt, Ihre Pipeline zu erstellen.• Die AWS CloudFormation-Ressource AWS:: IAM:: Role erstellt die AWS CloudFormation-IAM-

Auftragnehmer-Rolle, die AWS CodeStar Berechtigungen erteilt, Ihren Ressourcenstapel zu erstellen.• Die AWS CloudFormation-Ressource AWS:: IAM:: Role erstellt die AWS CloudFormation-IAM-

Auftragnehmer-Rolle, die AWS CodeStar Berechtigungen erteilt, Ihren Ressourcenstapel zu erstellen.• Die AWS CloudFormation-Ressource AWS:: IAM:: Role erstellt die AWS CloudFormation-IAM-

Auftragnehmer-Rolle, die AWS CodeStar Berechtigungen erteilt, Ihren Ressourcenstapel zu erstellen.• Die AWS CloudFormation-Ressource AWS:: Events:: Rule erstellt die CloudWatch-Ereignisse-Regel, die

Ihr Repository für Push-Ereignisse überwacht.• Die AWS CloudFormation-Ressource AWS::IAM::Role erstellt die CloudWatch-Ereignisse-IAM-Rolle.

Schritt 3: Testen Sie Ihre Toolchain-Vorlage in AWSCloudFormationBevor Sie Ihre Toolchain-Vorlage hochladen, können Sie Ihre Toolchain-Vorlage in AWS CloudFormationtesten und etwaige Fehler beheben.

1. Speichern Sie Ihre aktualisierte Vorlage auf Ihrem lokalen Computer und öffnen Sie die AWSCloudFormation-Konsole. Wählen Sie Create Stack aus. Ihre neuen Ressourcen sollten in der Listeangezeigt werden.

2. Überprüfen Sie Ihren Stapel auf eventuelle Fehler bei der Stapelerstellung.3. Nachdem Ihre Tests abgeschlossen sind, löschen Sie den Stapel.

Note

Stellen Sie sicher, dass Sie Ihren Stapel und alle in AWS CloudFormation erstelltenRessourcen löschen. Andernfalls könnte es bei der Erstellung Ihres Projekts zu Fehlern beibereits verwendeten Ressourcennamen kommen.

33

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codecommit-repository.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codedeploy-application.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-bucket.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-s3-policy.html

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html





https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-events-rule.html


AWS CodeStar BenutzerhandbuchSchritt 4: Laden Sie Ihren Quellcode

und Ihre Toolchain-Vorlage hoch

Schritt 4: Laden Sie Ihren Quellcode und IhreToolchain-Vorlage hochUm ein AWS CodeStar-Projekt zu erstellen, müssen Sie zunächst Ihren Quellcode in eine.zip-Datei packenund in Amazon S3 ablegen. AWS CodeStar initialisiert Ihr Repository mit diesen Inhalten. Sie geben diesenSpeicherort in Ihrer Eingabedatei an, wenn Sie den Befehl zum Erstellen Ihres Projekts in der AWS CLIausführen.

Außerdem müssen Sie Ihre toolchain.yml-Datei hochladen und diese in Amazon S3 ablegen. Siegeben diesen Speicherort in Ihrer Eingabedatei an, wenn Sie den Befehl zum Erstellen Ihres Projekts in derAWS CLI ausführen

Laden Sie Ihren Quellcode und Ihre Toolchain-Vorlage hoch

1. Die folgende Beispieldateistruktur zeigt die Quelldateien und die Toolchain-Vorlage, die bereit sind,gezippt und hochgeladen zu werden. Der Beispielcode enthält die Datei template.yml. Denken Siedaran, dass sich diese Datei von der Datei toolchain.yml unterscheidet.

lssrc toolchain.yml

ls src/README.md app.js buildspec.yml index.js package.json template.yml tests

2. Erstellen Sie die Zip-Datei für die Quelltextdateien.

cd src; zip -r "../src.zip" *; cd ../ adding: README.md (deflated 58%) adding: app.js (deflated 43%) adding: buildspec.yml (deflated 48%) adding: index.js (deflated 45%) adding: package.json (deflated 50%) adding: template.yml (deflated 53%) adding: tests/ (stored 0%) adding: tests/test.js (deflated 64%)

3. Rufen Sie den Befehl cp auf und fügen Sie die Dateien als Parameter hinzu.

Die folgenden Befehle laden die .zip-Datei und die Datei toolchain.yml nach Amazon S3 hoch.

aws s3 cp src.zip s3://MyBucket/src.zip aws s3 cp toolchain.yml s3://MyBucket/toolchain.yml

So konfigurieren Sie Ihren Amazon S3-Bucket für die Freigabe Ihres Quellcodes

• Da Sie Ihren Quellcode und Ihre Toolchain in Amazon S3 speichern, können Sie die Amazon S3-Bucket-Richtlinien und Objekt-ACLs verwenden, um sicherzustellen, dass andere IAM-Benutzer oderAWS-Konten Projekte aus Ihren Beispielen erstellen können. AWS CodeStar stellt sicher, dass jederBenutzer, der ein benutzerdefiniertes Projekt erstellt, Zugriff auf die Toolchain und die Quelle hat, dieer verwenden möchte.

Um jemandem die Verwendung Ihres Beispiels zu ermöglichen, führen Sie die folgenden Befehle aus:

aws s3api put-object-acl --bucket MyBucket --key toolchain.yml --acl public-read

34

AWS CodeStar BenutzerhandbuchSchritt 5: Erstellen eines Projekts in AWS CodeStar

aws s3api put-object-acl --bucket MyBucket --key src.zip --acl public-read

Schritt 5: Erstellen eines Projekts in AWS CodeStarVerwenden Sie diese Schritte, um Ihr Projekt zu erstellen.

Important

Stellen Sie sicher, dass Sie die bevorzugte AWS-Region in AWS CLI konfigurieren. Ihr Projektwird in der AWS-Region angelegt, die in der AWS CLI konfiguriert ist.

1. Führen Sie den Befehl create-project aus und beziehen Sie den --generate-cli-skeleton-Parameter ein.

aws codestar create-project --generate-cli-skeleton

Daten im JSON-Format werden in der Ausgabe angezeigt. Kopieren Sie die Daten in eine Datei (z. B.input.json) auf Ihrem lokalen Computer oder auf einer Instance, auf der AWS CLI installiert ist.Ändern Sie die kopierten Daten wie im Folgenden dargestellt und speichern Sie die Ergebnisse.Diese Eingabedatei ist für ein Projekt namens MyProject mit einem Bucket-Namen von myBucketkonfiguriert.

• Stellen Sie sicher, dass Sie den Parameter roleArn angeben. Für benutzerdefinierte Vorlagen, wiez. B. die Beispielvorlage in diesem Tutorial müssen Sie eine Rolle angeben. Diese Rolle muss überBerechtigungen zum Erstellen aller Ressourcen verfügen, die in Schritt 2: Laden Sie die Beispiel-Toolchain-Vorlage herunter (p. 32) angegeben sind.

• Stellen Sie sicher, dass Sie den Parameter ProjectId unter stackParameters angeben. DieBeispielvorlage für dieses Tutorial benötigt diesen Parameter.

{ "name": "MyProject", "id": "myproject", "description": "Sample project created with the CLI", "sourceCode": [ { "source": { "s3": { "bucketName": "MyBucket", "bucketKey": "src.zip" } }, "destination": { "codeCommit": { "name": "myproject" } } } ], "toolchain": { "source": { "s3": { "bucketName": "MyBucket", "bucketKey": "toolchain.yml" } }, "roleArn": "role_ARN", "stackParameters": {

35

AWS CodeStar BenutzerhandbuchAlexa Skill-Projekt – Tutorial

"ProjectId": "myproject" } }}

2. Wechseln Sie in das Verzeichnis, das die soeben gespeicherte Datei enthält, und führen Sie denBefehl create-project erneut aus. Schließen Sie den Parameter --cli-input-json ein.

aws codestar create-project --cli-input-json file://input.json

3. Ist der Befehl erfolgreich, gibt er als Ausgabe Daten zurück, die wie folgt aussehen sollten:

{ "id": "project-ID", "arn": "arn"}

• Die Ausgabe enthält Informationen über das neue Projekt:• Der Wert id repräsentiert die Projekt-ID.• Der Wert arn zeigt den ARN des Projekts an.

4. Verwenden Sie den Befehl describe-project, um den Status Ihrer Projekterstellung zu überprüfen.Schließen Sie den Parameter --id ein.

aws codestar describe-project --id <project_ID>

In der Ausgabe erscheinen ähnliche Daten wie die folgenden:

{ "name": "MyProject", "id": "myproject", "arn": "arn:aws:codestar:us-east-1:account_ID:project/myproject", "description": "", "createdTimeStamp": 1539700079.472, "stackId": "arn:aws:cloudformation:us-east-1:account_ID:stack/awscodestar-myproject/stack-ID", "status": { "state": "CreateInProgress" }}

• Die Ausgabe enthält Informationen über das neue Projekt:• Der Wert id repräsentiert die eindeutige Projekt-ID.• Der Wert state stellt den Status der Projekterstellung dar, z.B. CreateInProgress oderCreateComplete.

Während Ihr Projekt erstellt wird, können Sie Teammitglieder hinzufügen (p. 96) oder denZugriff (p. 56) auf Ihr Projekt-Repository über die Befehlszeile oder Ihre bevorzugte IDE konfigurieren.

Tutorial: Erstellen eines Alexa-Skill-Projekts in AWSCodeStar

AWS CodeStar ist ein Cloud-basierter Entwicklungsservice auf Amazon Web Services (AWS), der Ihnendie Tools zur Verfügung stellt, die Sie für eine schnelle Entwicklung, Erstellung und Bereitstellung von

36

AWS CodeStar BenutzerhandbuchVoraussetzungen

Anwendungen auf AWS benötigen. Mit AWS CodeStar können Sie Ihre gesamte Continuous Delivery-Toolchain in wenigen Minuten einrichten und Ihren Code so schneller veröffentlichen. Erstellen Siemit den Alexa Skill-Projektvorlagen auf AWS CodeStar ein einfaches „Hallo Welt“-Alexa-Skill direktaus Ihrem AWS-Konto heraus mit nur wenigen Klicks. Die Vorlagen erstellen auch eine grundlegendeBereitstellungspipeline, die Sie mit einem Workflow zur kontinuierlichen Bereitstellung (ContinuousIntegration, CI) für die Skill-Entwicklung vertraut macht.

Der Hauptvorteil der Erstellung von Alexa-Skills mit AWS CodeStar besteht darin, dass Sie mit der Skill-Entwicklung in AWS beginnen und Ihr Amazon-Entwicklerkonto mit dem Projekt verbinden können, umSkills direkt von AWS aus in die Entwicklungsstufe zu bringen. Sie erhalten auch eine einsatzbereiteDeployment (CI)-Pipeline mit einem Repository mit dem gesamten Quellcode für das Projekt. Sie könnendieses Repository mit Ihrer bevorzugten IDE konfigurieren, um Skills mit Tools zu erstellen, die Sie kennen.

Voraussetzungen• Erstellen Sie ein Amazon-Entwicklerkonto, indem Sie auf https://developer.amazon.com gehen. Die

Anmeldung ist kostenlos. Dieses Konto besitzt Ihre Alexa-Skills.• Wenn Sie kein AWS-Konto haben, führen Sie die folgenden Schritte zum Erstellen eines Kontos durch.

So melden Sie sich bei AWS an

1. Rufen Sie https://aws.amazon.com/ auf und wählen Sie Create an AWS Account (AWS-Kontoerstellen) aus.

Note

Wenn Sie sich zuvor mit Stammbenutzer des AWS-Kontos-Anmeldeinformationen an derAWS Management Console angemeldet haben, wählen Sie Sign in to a different account(Mit einem anderen Konto anmelden). Wenn Sie sich zuvor mit IAM-Anmeldeinformationenan der Konsole angemeldet haben, wählen Sie Sign-in using root account credentials (MitStammkonto-Anmeldeinformationen anmelden). Wählen Sie anschließend Create a newAWS account (Neues AWS-Konto erstellen) aus.

2. Folgen Sie den Onlineanweisungen.

Important

Nachdem Sie das Alexa Skill-Projekt erstellt haben, nehmen Sie alle Änderungen nur noch imProjekt-Repository vor. Wir empfehlen, dieses Skill nicht direkt mit anderen Alexa Skills Kit-Toolswie der ASK CLI- oder ASK-Entwicklerkonsole zu bearbeiten. Diese Tools werden nicht in dasProjekt-Repository integriert. Wenn Sie sie verwenden, hat dies zur Folge, dass der Skill und derRepository-Code nicht mehr synchron sind.

Schritt 1: Erstellen des Projekts und Verbinden IhresAmazon-EntwicklerkontosIn diesem Tutorial erstellen Sie einen Skill mit Node.js, das auf AWS Lambda läuft. Die meisten Schrittesind für andere Sprachen gleich, obwohl der Name des Skills unterschiedlich ist. In der Datei README.mdim Projektarchiv finden Sie Details zu der von Ihnen gewählten Projektvorlage.

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die AWS CodeStar-Konsole unterhttps://console.aws.amazon.com/codestar/.

2. Wählen Sie die AWS-Region, in der Sie das Projekt und die zugehörigen Ressourcen erstellen möchten.Die Alexa Skill-Laufzeit ist nur in den folgenden AWS-Regionen verfügbar:• Asien-Pazifik (Tokio)

37

https://developer.amazon.com/

https://aws.amazon.com/


AWS CodeStar BenutzerhandbuchSchritt 2: Testen des Skills im Alexa Simulator

• EU (Irland)• USA Ost (Nord-Virginia)• USA West (Oregon)

3. Wählen Sie Create a new project (Neues Projekt erstellen). Falls Create a new project (Neues Projekterstellen) nicht angezeigt wird, wählen Sie Start a project (Projekt starten) aus.

4. Auf der Seite Choose a project template (Auswählen einer Projektvorlage):a. Wählen Sie bei Application category (Anwendungskategorie) Alexa Skill aus.b. Wählen Sie bei Programming languages (Programmiersprachen) Node.js aus.c. Wählen Sie das Feld mit den von Ihnen gewählten Optionen.

5. Geben Sie für Project name (Projektname) einen Namen für Ihr Projekt ein (z. B.: Mein Alexa Skill).Wenn Sie einen anderen Namen verwenden, stellen Sie sicher, dass Sie ihn durchweg in diesemTutorial verwenden. AWS CodeStar wählt einen zugehörigen Bezeichner für dieses Projekt als ProjectID (Projekt-ID) (z. B. my-alexa-skill). Wenn Sie eine andere Projekt-ID sehen, müssen Sie diese imgesamten Tutorial verwenden.

6. Wählen Sie in diesem Tutorial AWS CodeCommit für das Repository und ändern Sie den Wert für denRepository name (Repository-Namen) nicht.

7. Wählen Sie Connect Amazon developer account (Amazon-Entwicklerkonto verbinden) aus, um auf IhrAmazon-Entwicklerkonto für das Hosting des Skills zu verlinken.

8. Melden Sie sich mit Ihren Amazon-Entwickleranmeldeinformationen an. Wählen Sie Allow.9. Wenn Sie mehrere Anbieter-IDs mit Ihrem Amazon-Entwicklerkonto verknüpft haben, wählen Sie

diejenige aus, die Sie für dieses Projekt verwenden möchten. Stellen Sie sicher, dass Sie ein Konto mitder zugewiesenen Rolle Administrator oder Entwickler verwenden.

10.Wählen Sie Next.11.Behalten Sie die Markierung für das Kontrollkästchen AWS CodeStar would like permission to administer

AWS resources on your behalf (AWS CodeStar benötigt Berechtigungen zum Verwalten von AWS-Ressourcen in Ihrem Auftrag) bei, und wählen Sie dann Create Project (Projekt erstellen) aus.

12.(Optional) Wenn Sie AWS CodeStar zum ersten Mal in dieser AWS-Region verwenden, geben Sie denAnzeigenamen und die E-Mail-Adresse ein, die AWS CodeStar für Ihren IAM-Benutzer verwenden soll.Wählen Sie Next.

13.Wählen Sie für Pick how you want to edit your project code (Wählen Sie aus, wie Sie Ihren Projektcodebearbeiten möchten) die Option Skip (Überspringen) aus. Sie können später Ihre lokale Arbeitsstationeinrichten, um den Code des Projekts zu bearbeiten.

14.Warten Sie, bis AWS CodeStar das Projekt erstellt hat. Dies kann einige Minuten dauern. Fahren Sienicht fort, bis Sie das Willkommensbanner sehen.

Schritt 2: Testen des Skills im Alexa SimulatorIm ersten Schritt hat AWS CodeStar einen Skill für Sie erstellt und in der Alexa Skill-Entwicklungsphasebereitgestellt. Als Nächstes testen Sie das Skill im Alexa-Simulator.

1. Wählen Sie auf der Kachel Application endpoints (Anwendungsendpunkte) rechts in der AWS CodeStar-Konsole Alexa simulator (Alexa Simulator) aus. Eine neue Registerkarte öffnet sich mit dem AlexaSimulator.

2. Melden Sie sich mit Ihren Amazon-Entwickleranmeldeinformationen für das Konto an, das Sie inSchritt 1 mit Ihrem Projekt verbunden haben.

3. Wählen Sie bei Test Development (Entwicklung) aus, um die Testfunktion zu aktivieren.4. Geben Sie ask hello node hello ein. Der Standardname für den Aufruf Ihres Skills lautet hello

node.5. Ihr Skill sollte mit Hello World! antworten.

38

AWS CodeStar BenutzerhandbuchSchritt 3: Entdecken der Projekt-Ressourcen

Wenn der Skill im Alexa-Simulator aktiviert ist, können Sie ihn auch auf einem Alexa-fähigen Gerätaufrufen, das in Ihrem Amazon-Entwicklerkonto registriert ist. Um Ihren Skill auf einem Gerät zu testen,sagen Sie Alexa, sage Hello Node, sage Hallo.

Weitere Informationen über den Alexa-Simulator finden Sie unter Testen Ihrer Skills in derEntwicklerkonsole.

Schritt 3: Entdecken der Projekt-RessourcenIm Rahmen der Erstellung des Projekts hat AWS CodeStar auch AWS-Ressourcen in Ihrem Namenerstellt. Zu diesen Ressourcen gehören ein Projekt-Repository mit CodeCommit, eine Deployment-Pipelinemit CodePipeline und eine AWS Lambda-Funktion. Sie können auf diese Ressourcen über die linkeNavigationsleiste zugreifen. Wenn Sie beispielsweise Code auswählen, wird das CodeCommit-Repositorydes Projekts geöffnet. Sie können den Status der Pipeline-Bereitstellung in der Kachel Continuousdeployment (Kontinuierliche Bereitstellung) auf dem Projekt-Dashboard einsehen (wählen Sie bei BedarfDashboard in der linken Navigationsleiste aus). Sie können eine vollständige Liste der AWS-Ressourcenanzeigen, die im Rahmen Ihres Projekts erstellt wurden, indem Sie in der linken Navigationsleiste Project(Projekt) auswählen. Diese Liste enthält Links zu den einzelnen Ressourcen.

Schritt 4: Ändern der Antwort Ihres SkillsIn diesem Schritt nehmen Sie eine kleine Änderung an der Reaktion Ihres Skills vor, um denIterationszyklus zu verstehen.

1. Klicken Sie in der linken Navigationsleiste auf Code. Der Code in Ihrem Repository wird in einer neuenRegisterkarte geöffnet. Dieses Repository enthält die Build-Spezifikation (buildspec.yml), den AWSCloudFormation-Anwendungsstapel (template.yml), die Readme-Datei und den Quellcode Ihres Skills imSkill-Paketformat (Projektstruktur).

2. Navigieren Sie zur Datei lambda > custom > index.js (bei Node.js). Diese Datei enthält den Code für dieBearbeitung Ihrer Anfrage, der das ASK SDK verwendet.

3. Wählen Sie Edit (Bearbeiten) aus.4. Ersetzen Sie die Zeichenkette Hello World! in Zeile 24 durch die Zeichenkette Hello. How are

you?.5. Scrollen Sie nach unten zum Ende der Datei. Geben Sie Autorenname und E-Mail-Adresse und eine

optionale Commit-Nachricht ein.6. Wählen Sie Commit changes (Commit für Änderungen durchführen) aus, um die Änderungen in das

Repository zu übertragen.7. Kehren Sie zum Projekt-Dashboard in AWS CodeStar zurück und überprüfen Sie die Kachel Continuous

deployment (Kontinuierliche Bereitstellung). Sie sollten nun sehen, wie die Pipeline bereitgestellt wird.8. Wenn die Pipeline die Bereitstellung beendet hat, testen Sie Ihren Skill erneut im Alexa-Simulator. Ihr

Skill sollte nun mit Hello. How are you? antworten.

Schritt 5: Einrichten der lokalen Arbeitsstation, um eineVerbindung zu Ihrem Projekt-Repository herzustellenBisher haben Sie eine kleine Änderung am Quellcode direkt von der CodeCommit-Konsole ausvorgenommen. In diesem Schritt konfigurieren Sie das Projekt-Repository mit Ihrer lokalen Arbeitsstation,sodass Sie Code von der Befehlszeile oder Ihrer bevorzugten IDE aus bearbeiten und verwalten können. Inden folgenden Schritten wird erläutert, wie Sie Befehlszeilen-Tools einrichten.

1. Navigieren Sie bei Bedarf zum Projekt-Dashboard in AWS CodeStar.

39

https://developer.amazon.com/docs/devconsole/test-your-skill.html#test-simulator

https://developer.amazon.com/docs/devconsole/test-your-skill.html#test-simulator

https://developer.amazon.com/docs/smapi/skill-package-api-reference.html#skill-package-format

https://developer.amazon.com/docs/quick-reference/use-sdks-quick-reference.html

AWS CodeStar BenutzerhandbuchNächste Schritte

2. Wählen Sie in der linken Navigationsleiste Project (Projekt) und dann Connect tools (Tools verbinden)aus.

3. Wählen Sie Command line tools (Befehlszeilen-Tools) aus.4. Wählen Sie bei Clone repository URL (URL zum Klonen des Repositorys) HTTPS aus.5. Wählen Sie See instructions (Anweisungen anzeigen) aus.6. Folgen Sie den Anweisungen, um die folgenden Aufgaben auszuführen:

a. Installieren Sie Git auf Ihrem lokalen Arbeitsplatzrechner von einer Website wie z. B. Git Downloads.b. Installieren der AWS CLI. Informationen hierzu finden Sie unter Installieren der AWS-

Befehlszeilenschnittstelle.c. Konfigurieren Sie die AWS CLI mit Ihrem IAM-Benutzerzugriffsschlüssel und Ihrem geheimen

Schlüssel. Weitere Informationen finden Sie unter Konfigurieren der AWS-Befehlszeilenschnittstelle.d. Klonen Sie das CodeCommit-Repository Ihres Projekts auf Ihre lokale Workstation. Weitere

Informationen finden Sie unter Herstellen einer Verbindung mit einem AWS CodeCommit-Repository.

Nächste SchritteDieses Tutorial zeigte Ihnen, wie Sie mit einem grundlegenden Skill beginnen können. Um Ihren Weg zurEntwicklung von Skills fortzusetzen, lesen Sie die folgenden Ressourcen.

• Verstehen Sie die Grundlagen eines Skills, indem Sie sich How Alexa Skills Work und andere Videos aufdem Alexa Developers YouTube-Kanal ansehen.

• Verstehen Sie die verschiedenen Komponenten Ihres Skills, indem Sie die Dokumentation für das Skill-Paketformat, die Skill-Manifestschemas und die Interaktionsmodell-Schemas lesen.

• Setzen Sie Ihre Idee für einen Skill um, indem Sie die Dokumentation für das Alexa Skills Kit und die ASKSDKs lesen.

40


http://docs.aws.amazon.com/cli/latest/userguide/installing.html

http://docs.aws.amazon.com/cli/latest/userguide/installing.html

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

https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-connect.html

https://www.youtube.com/watch?v=hbH6gZoKcbM



https://developer.amazon.com/docs/smapi/skill-manifest.html

https://developer.amazon.com/docs/smapi/interaction-model-schema.html

https://developer.amazon.com/docs/ask-overviews/build-skills-with-the-alexa-skills-kit.html



AWS CodeStar BenutzerhandbuchAWS CodeStar Projektdateien und Ressourcen

AWS CodeStar-ProjektvorlagenMit den AWS CodeStar-Projektvorlagen können Sie mit einer Beispielanwendung beginnen und diese mitAWS-Ressourcen bereitstellen, die zur Unterstützung Ihres Entwicklungsprojekts erstellt wurden. WennSie eine Projektvorlage für AWS CodeStar wählen, werden der Anwendungstyp, die Programmierspracheund die Rechenplattform für Sie bereitgestellt. Nachdem Sie Projekte mit Webanwendungen, Webservices,Alexa-Kenntnissen und statischen Webseiten erstellt haben, können Sie die Beispielanwendung durch Ihreeigene ersetzen.

Nachdem AWS CodeStar Ihr Projekt erstellt hat, können Sie die AWS-Ressourcen ändern, die dieBereitstellung Ihrer Anwendung unterstützen. AWS CodeStar arbeitet mit AWS CloudFormation, damitSie Code verwenden können, um Support-Services und Server/Serverlose-Plattformen in der Cloudzu erstellen. AWS CloudFormation ermöglicht Ihnen, Ihre gesamte Infrastruktur in einer Textdatei zumodellieren.

Themen• AWS CodeStar Projektdateien und Ressourcen (p. 41)• Fangen Sie an: Wählen Sie eine Projektvorlage aus (p. 42)• Wie Sie Änderungen an Ihrem AWS CodeStar-Projekt vornehmen können (p. 44)

AWS CodeStar Projektdateien und RessourcenEin AWS CodeStar Projekt ist eine Kombination aus Quellcode und erstellten Ressourcen, um denCode bereitzustellen. Die Sammlung von Ressourcen, die Ihnen bei der Erstellung, Freigabe undBereitstellung Ihres Codes helfen, heißt Toolchain-Ressourcen. Bei der Projekterstellung stellt eine AWSCloudFormation-Vorlage Ihre Toolchain-Ressourcen in einer CI/CD-Pipeline (Continuous Integration/Continuous Deployment) bereit.

Sie können AWS CodeStar verwenden, um Projekte auf zwei Arten zu erstellen, abhängig von IhrerErfahrung mit der Erstellung von AWS-Ressourcen:

• Wenn Sie die Konsole zum Erstellen eines Projekts verwenden, erstellt AWS CodeStar Ihre Toolchain-Ressourcen, einschließlich Ihres Repositorys, und füllt Ihr Repository mit Anwendungsbeispiel-Code undProjektdateien. Verwenden Sie die Konsole, um schnell Beispielprojekte basierend auf einer Reihe vonvorkonfigurierten Projektoptionen einzurichten.

• Wenn Sie die CLI zum Erstellen eines Projekts verwenden, stellen Sie die AWS CloudFormation-Vorlage zur Verfügung, die Ihre Toolchain-Ressourcen erstellt, sowie auch den Anwendungsquellcode.Verwenden Sie die CLI, um AWS CodeStar zu erlauben, Ihr Projekt aus Ihrer Vorlage zu erstellen unddann Ihr Repository mit Ihrem Beispielcode zu füllen.

Ein AWS CodeStar Projekt bietet eine einheitliche und zentrale Verwaltung. Sie können den AssistentenCreate project in der Konsole verwenden, um ein Beispielprojekt einzurichten. Sie können es dann alsKollaborationsplattform für die Verwaltung von Berechtigungen und Ressourcen für Ihr Team verwenden.Weitere Informationen finden Sie unter Was ist AWS CodeStar? (p. 1). Wenn Sie die Konsole zum Erstelleneines Projekts verwenden, wird Ihr Quellcode als Beispielcode bereitgestellt, und Ihre CI/CD-Toolchain-Ressourcen werden für Sie erstellt.

Wenn Sie ein Projekt in der Konsole erstellen, stellt AWS CodeStar die folgenden Ressourcen zurVerfügung:

• Ein Code-Repository in CodeCommit oder GitHub.

41

AWS CodeStar BenutzerhandbuchFangen Sie an: Wählen Sie eine Projektvorlage aus

• Im Projekt-Repository eine Datei README.md, die Details zu Dateien und Verzeichnissen enthält.• Im Projekt-Repository befindet sich eine Datei template.yml, die die Definition für den Laufzeit-

Stack Ihrer Anwendung speichert. Mit dieser Datei können Sie Projektressourcen hinzufügen oderändern, die keine Toolchain-Ressourcen sind, wie z.B. AWS-Ressourcen für Benachrichtigungen,Datenbankunterstützung, Überwachung und Tracing.

• AWS-Services und Ressourcen, die in Verbindung mit Ihrer Pipeline erstellt wurden, wie z.B. der AmazonS3-Artefakt-Bucket, Amazon CloudWatch Events und zugehörige Dienstrollen.

• Eine funktionierende Beispielanwendung mit vollständigem Quellcode und einem öffentlichen HTTP-Endpunkt.

• Eine AWS-Compute-Ressource, die auf dem AWS CodeStar-Projektvorlagentyp basiert:• Eine Lambda-Funktion.• Eine Amazon EC2-Instance.• Eine AWS Elastic Beanstalk-Umgebung.

• Starten von 6. Dezember 2018 PDT:• Eine Berechtigungsgrenze, die eine spezielle IAM-Richtlinie zur Kontrolle des Zugriffs auf

Projektressourcen ist. Die Berechtigungsgrenze ist standardmäßig Rollen im Beispielprojekt angefügt.Weitere Informationen finden Sie unter IAM-Berechtigungsgrenze für Auftragnehmerrollen (p. 115).

• Eine AWS CloudFormation IAM-Rolle für das Erstellen von Projektressourcen mithilfe von AWSCloudFormation, mit Berechtigungen für alle von AWS CloudFormation unterstützten Ressourcen,einschließlich IAM-Rollen.

• Eine Toolchain-IAM-Rolle.• Im Anwendungsstack definierte Ausführungsrollen für Lambda, die Sie ändern können.

• Vor 6. Dezember 2018 PDT:• Eine AWS CloudFormation IAM-Rolle für die Erstellung von Projektressourcen mit Unterstützung für

einen begrenzten Satz von AWS CloudFormation-Ressourcen.• Eine IAM-Rolle zum Erstellen einer CodePipeline-Ressource.• Eine IAM-Rolle zum Erstellen einer CodeBuild-Ressource.• Eine IAM-Rolle zum Erstellen einer CodeDeploy-Ressource, falls zutreffend für Ihren Projekttyp.• Eine IAM-Rolle zum Erstellen der Amazon EC2-Webapp, falls zutreffend für Ihren Projekttyp.• Eine IAM-Rolle zum Erstellen einer CloudWatch-Ereignisse-Ressource.• Eine Ausführungsrolle für Lambda, die dynamisch modifiziert wird, um einen Teilsatz von Ressourcen

aufzunehmen.

Das Projekt beinhaltet auch ein interaktives Dashboard, das den Status, Links zur Teamverwaltung, Linkszu Einrichtungsanweisungen für IDEs oder Ihr Repository und eine Commit-Historie der Änderungenam Quellcode im Repository anzeigt. Sie können auch Tools zur Verbindung mit externen Tools zurProblemverfolgung auswählen, wie z.B. Jira.

Fangen Sie an: Wählen Sie eine Projektvorlage ausWenn Sie ein AWS CodeStar-Projekt in der Konsole auswählen, wählen Sie aus einer Reihe vonvorkonfigurierten Optionen mit Beispielcode und Ressourcen, um einen schnellen Einstieg zu ermöglichen.Diese Optionen werden Projektvorlagen genannt. Jede AWS CodeStar-Projektvorlage besteht auseinem Anwendungstyp, einer Programmiersprache und einer Rechenplattform. Die von Ihnen gewählteKombination bestimmt die Projektvorlage.

Wählen Sie einen Vorlagen-Anwendungstyp ausJede Vorlage konfiguriert eine der folgenden Anwendungstypen:

42

AWS CodeStar BenutzerhandbuchWählen Sie eine Programmiersprachenvorlage

• Webservice

Ein Webservice wird für Aufgaben verwendet, die im Hintergrund laufen, wie z.B. der Aufruf von APIs.Nachdem AWS CodeStar Ihr Beispiel-Webservice-Projekt erstellt hat, können Sie die Endpunkt-URL wählen, um die Ausgabe von "Hello World" zu sehen, aber die primäre Verwendung diesesAnwendungstyps ist keine Benutzeroberfläche (UI). Die AWS CodeStar-Projektvorlagen in dieserKategorie unterstützen die Entwicklung in Ruby, Java, ASP.NET, PHP und mehr.

• Webanwendung

Eine Webanwendung verfügt über eine Benutzeroberfläche. Nachdem AWS CodeStar Ihr Beispiel-Webanwendungsprojekt erstellt hat, können Sie die Endpunkt-URL auswählen, um eine interaktiveWebanwendung zu sehen. Die AWS CodeStar-Projektvorlagen in dieser Kategorie unterstützen dieEntwicklung in Ruby, Java, ASP.NET, PHP und mehr.

• Statische Website

Wählen Sie diese Vorlage, wenn Sie ein Projekt für eine HTML-Website benötigen. Die AWS CodeStar-Projektvorlagen in dieser Kategorie unterstützen die Entwicklung in HTML5.

• Alexa-Skill

Wählen Sie diese Vorlage aus, wenn Sie ein Projekt für einen Alexa-Skill mit einer AWS Lambda-Funktion anlegen möchten. Wenn Sie das Skill-Projekt erstellen, gibt AWS CodeStar einen Amazon-Resourcennamen (ARN) zurück, den Sie als Service-Endpunkt verwenden können. WeitereInformationen finden Sie unter Bereitstellen eines benutzerdefinierten Skills als AWS Lambda-Funktion.

Note

Lambda-Funktionen für Alexa-Skills werden nur in den Regionen USA Ost (Nord-Virginia), USAWest (Oregon), EU (Irland) und Asien-Pazifik (Tokio) unterstützt.

• Config-Regel

Wählen Sie diese Vorlage, wenn Sie ein Projekt für eine AWS Config-Regel benötigen, mit der SieRegeln für AWS-Ressourcen in Ihrem Konto automatisieren können. Die Funktion gibt einen ARNzurück, die Sie als Service-Endpunkt für Ihre Regel verwenden können.

Wählen Sie eine ProgrammiersprachenvorlageWenn Sie eine Projektvorlage auswählen, wählen Sie eine Programmiersprache wie Ruby, Java, ASP.NET,PHP, Node.js und mehr.

Wählen Sie eine Compute-Plattform-VorlageJede Vorlage konfiguriert einen der folgenden Compute-Plattform-Typen:

• Wenn Sie sich für ein AWS Elastic Beanstalk-Projekt entscheiden, stellen Sie es in einer AWS ElasticBeanstalk-Umgebung auf Amazon Elastic Compute Cloud-Instances in der Cloud bereit.

• Wenn Sie ein Amazon EC2-Projekt wählen, erstellt AWS CodeStar Linux EC2-Instances, um IhreAnwendung in der Cloud zu hosten. Ihre Projektteammitglieder können auf die Instances zugreifen, undIhr Team verwendet das Schlüsselpaar, das Sie SSH in Ihren Amazon EC2-Instances zur Verfügungstellen. AWS CodeStar hat auch eine verwaltete SSH, die die Berechtigungen der Teammitglieder zurVerwaltung von Schlüsselpaarverbindungen verwendet.

• Wenn Sie AWS Lambda wählen, erstellt AWS CodeStar eine serverlose Umgebung, auf die überAmazon API Gateway zugegriffen wird, ohne dass Instances oder Server gewartet werden müssen.

43

https://developer.amazon.com/docs/custom-skills/host-a-custom-skill-as-an-aws-lambda-function.html

AWS CodeStar BenutzerhandbuchWie Sie Änderungen an Ihrem AWS

CodeStar-Projekt vornehmen können

Wie Sie Änderungen an Ihrem AWS CodeStar-Projekt vornehmen können

Sie können Ihr Projekt aktualisieren, indem Sie Folgendes ändern:

• Den Beispiel-Code und Programmiersprachenressourcen für Ihre Anwendung.• Ressourcen, die die Infrastruktur bilden, in der Ihre Anwendung gespeichert und bereitgestellt wird

(Betriebssysteme, unterstützende Anwendungen und Services, Bereitstellungsparameter und die Cloud-Compute-Plattform). Sie können die Anwendungsressourcen in der template.yml-Datei ändern. Diesist die AWS CloudFormation-Datei, die die Laufzeitumgebung Ihrer Anwendung modelliert.

Note

Wenn Sie mit einem Alexa Skills AWS CodeStar-Projekt arbeiten, können Sie außerhalb desAWS CodeStar-Source-Repositorys (CodeCommit oder GitHub) keine Änderungen an demSkill vornehmen. Wenn Sie den Skill im Alexa-Entwicklerportal bearbeiten, ist die Änderungmöglicherweise nicht im Quell-Repository sichtbar und die beiden Versionen sind nicht synchron.

Ändern des Anwendungsquellcodes und Push vonÄnderungenUm Beispiel-Quellcode, Skripte und andere Anwendungsquelldateien zu ändern, bearbeiten Sie Dateien inIhrem Quell-Repository mit:

• Verwenden des Bearbeitungsmodus in CodeCommit oder GitHub.• Öffnen des Projekts in einer integrierten Entwicklungsumgebung (IDE), wie z. B. AWS Cloud9.• Klonen des Repositorys lokal und dann Commit und Push Ihrer Änderungen. Weitere Informationen

finden Sie unter Schritt 5: Durchführen des Commits für eine Änderung (p. 11).

Ändern von Anwendungsressourcen mit der DateiTemplate.ymlAnstatt eine Infrastrukturressource manuell zu ändern, verwenden Sie AWS CloudFormation, um dieLaufzeitressourcen Ihrer Anwendung zu modellieren und bereitzustellen.

Sie können eine Anwendungsressource, wie beispielsweise eine Lambda-Funktion, in Ihrem Laufzeitstapeländern oder hinzufügen, indem Sie die Datei template.yml in Ihrem Projektarchiv bearbeiten. Siekönnen jede Ressource hinzufügen, die als AWS CloudFormation-Ressource verfügbar ist.

Um den Code oder die Einstellungen einer AWS Lambda-Funktion zu ändern, siehe Hinzufügen einerRessource zu einem Projekt (p. 73).

Ändern Sie die Datei template.yml im Repository Ihres Projekts, um den Typ der AWS CloudFormation-Ressourcen hinzuzufügen, die Anwendungsressourcen sind. Wenn Sie eine Anwendungsressourcezum Resources-Abschnitt der Datei template.yml hinzufügen, erstellen AWS CloudFormation undAWS CodeStar die Ressource für Sie. Informationen zu AWS CloudFormation-Ressourcen und ihreerforderlichen Eigenschaften finden Sie unter AWS Ressourcentypen-Referenz. Weitere Informationenfinden Sie im Code-Beispiel unter Schritt 1: Bearbeiten der CloudFormation-Auftragnehmer-Rolle imIAM (p. 74).

44

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html

AWS CodeStar BenutzerhandbuchÄndern von Anwendungsressourcen

mit der Datei Template.yml

AWS CodeStar ermöglicht die Implementierung von Bewährten Methoden durch Konfiguration undModellierung der Laufzeitumgebung Ihrer Anwendung.

Wie man Berechtigungen zum Ändern vonAnwendungsressourcen verwaltetWenn Sie AWS CloudFormation verwenden, um Laufzeit-Anwendungsressourcen hinzuzufügen,wie z.B. eine Lambda-Funktion, kann die AWS CloudFormation-Auftragnehmer-Rolle die bereitsvorhandenen Berechtigungen verwenden. Für einige Ressourcen der Laufzeitanwendung müssenSie die Berechtigungen der AWS CloudFormation-Workerrolle manuell anpassen, bevor Sie die Dateitemplate.yml bearbeiten.

Ein Beispiel für das Ändern der Berechtigungen der AWS CloudFormation-Auftragnehmer-Rolle finden Sieunter Schritt 5: Hinzufügen von Ressourcenberechtigungen mit einer Inline-Richtlinie (p. 76).

45

AWS CodeStar BenutzerhandbuchBewährte Methoden für die Sicherheit

für AWS CodeStar-Ressourcen

Bewährte Methoden für AWSCodeStar

AWS CodeStar ist mit einer Reihe von Produkten und Services integriert. In den folgenden Abschnittewerden bewährte Methoden für AWS CodeStar sowie verwandte Produkte und Services beschrieben.

Themen• Bewährte Methoden für die Sicherheit für AWS CodeStar-Ressourcen (p. 46)• Bewährte Methoden zum Festlegen von Versionen für Abhängigkeiten (p. 46)• Bewährte Methoden für die Überwachung und Protokollierung für AWS CodeStar-

Ressourcen (p. 46)

Bewährte Methoden für die Sicherheit für AWSCodeStar-Ressourcen

Sie sollten regelmäßig Patches anwenden, und überprüfen Sie die bewährten Methoden für dieSicherheit der von Ihrer Anwendung verwendeten Abhängigkeiten. Verwenden Sie diese bewährtenSicherheitsmethoden zur Aktualisierung Ihres Beispielcodes und zur Pflege Ihres Projekts in einerProduktionsumgebung:

• Verfolgen Sie aktuelle Sicherheitsankündigungen und Updates für Ihr Framework.• Bevor Sie Ihr Projekt bereitstellen, befolgen Sie die für Ihr Framework entwickelten bewährten Methoden.• Überprüfen Sie die Abhängigkeiten für Ihr Framework regelmäßig und aktualisieren Sie diese nach

Bedarf.• Jede AWS CodeStar-Vorlage enthält Konfigurationsanweisungen für Ihre Programmiersprache. Lesen

Sie die Datei README.md in Ihrem Quell-Repository.

Bewährte Methoden zum Festlegen von Versionenfür Abhängigkeiten

Der Beispiel-Quellcode in Ihrem AWS CodeStar-Projekt verwendet Abhängigkeiten, die in der Dateipackage.json in Ihrem Quell-Repository aufgeführt sind. Als bewährte Methode sollten Sie IhreAbhängigkeiten immer so einstellen, dass sie auf eine bestimmte Version verweisen. Dies ist bekanntals Pinning der Version. Wir empfehlen nicht, die Version auf latest zu setzen, da dies zu Änderungenführen kann, die Ihre Anwendung ohne Vorankündigung beeinträchtigen könnten.

Bewährte Methoden für die Überwachung undProtokollierung für AWS CodeStar-Ressourcen

Sie können die Protokollierungsfunktionen in AWS verwenden, um die Aktionen, die Benutzer in IhremKonto durchführen müssen, und die verwendeten Ressourcen festzulegen. Die Protokolldateien enthaltenFolgendes:

46

AWS CodeStar BenutzerhandbuchBewährte Methoden für die Überwachung undProtokollierung für AWS CodeStar-Ressourcen

• Datum und Uhrzeit der Aktionen.• Die Quell-IP-Adresse für eine Aktion.• Welche Aktionen aufgrund unzureichender Berechtigungen fehlgeschlagen sind.

AWS CloudTrail kann verwendet werden, um AWS-API-Aufrufe und zugehörige Ereignisse zuprotokollieren, die von einem AWS-Konto oder in seinem Namen getätigt wurden. Weitere Informationenfinden Sie unter Protokollieren von AWS CodeStar-API-Aufrufen mit AWS CloudTrail (p. 142).

47


Arbeiten mit Projekten in AWSCodeStar

Wenn Sie eine Projektvorlage für AWS CodeStar verwenden, können Sie schnell ein Projekt erstellen, dasbereits mit den benötigten Ressourcen konfiguriert ist, darunter:

• Quell-Repository• Build-Umgebung• Bereitstellungs- und Hosting-Ressourcen• Programmiersprache

Die Vorlage enthält sogar Beispiel-Sourcecode, so dass Sie sofort mit der Arbeit mit Ihrem Projektbeginnen können.

Sobald Sie ein Projekt haben, können Sie Ressourcen hinzufügen oder entfernen, das Projekt-Dashboardanpassen und den Fortschritt überwachen.

Das folgende Diagramm zeigt einen grundlegenden Workflow in einem AWS CodeStar-Projekt.

Ein Entwickler mit der AWSCodeStarFullAccess-Richtlinie erstellt ein Projekt und fügt Teammitgliederhinzu. Gemeinsam schreiben, erstellen, testen und stellen sie diesen Code bereit. Das Projekt-Dashboardstellt Tools bereit, die verwendet werden können, um in Echtzeit die Anwendungsaktivität anzuzeigenund Builds sowie Code durch die Bereitstellungspipeline hindurch zu überwachen und mehr. Das Teamverwendet die Team-Wiki-Kachel, um Informationen bewährte Methoden und Links auszutauschen.Dazu gehört die Software für die Problemnachverfolgung, um Fortschritte und Aufgaben nachverfolgenzu können. Wenn Kunden Anfragen und Feedback beisteuern, fügt das Team diese Informationen demProjekt hinzu und integriert sie in Ihre Projektplanungs- und Entwicklungsaktivitäten. Wenn das Projektwächst, nimmt die Zahl der Teammitglieder zu, um die Codebasis zu unterstützen.

48

AWS CodeStar BenutzerhandbuchErstellen eines Projekts

Erstellen eines Projekts in AWS CodeStarSie verwenden die AWS CodeStar-Konsole zum Erstellen eines Projekts. Wenn Sie eine Projektvorlageverwenden, richtet diese die erforderlichen Ressourcen für Sie ein. Die Vorlage enthält auch Beispielcode,mit dem Sie die Programmierung starten können.

Um ein Projekt zu erstellen, melden Sie sich mit einem IAM-Benutzer, der über die RichtlinieAWSCodeStarFullAccess oder gleichwertige Berechtigungen verfügt, bei der AWS ManagementConsole an. Weitere Informationen finden Sie unter Einrichten von AWS CodeStar (p. 3).

Note

Bevor Sie die Verfahren in diesem Thema abschließen können, müssen Sie zunächst die Schrittein Einrichten von AWS CodeStar (p. 3) durchführen.

Themen• Erstellen eines Projekts in AWS CodeStar (Konsole) (p. 49)• Erstellen eines Projekts in AWS CodeStar (AWS CLI) (p. 51)

Erstellen eines Projekts in AWS CodeStar (Konsole)Verwenden Sie die AWS CodeStar-Konsole zum Erstellen eines Projekts.

So erstellen Sie ein Projekt in AWS CodeStar

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die AWS CodeStar-Konsoleunter https://console.aws.amazon.com/codestar/.

Stellen Sie sicher, dass Sie sich bei der AWS-Region, in der Sie das Projekt und seine Ressourcenerstellen möchten, angemeldet haben. Wenn Sie beispielsweise ein Projekt in der Region USA Ost(Ohio) erstellen möchten, achten Sie darauf, dass Sie diese Region ausgewählt haben. Informationenüber die AWS-Regionen, in denen AWS CodeStar verfügbar ist, finden Sie unter Regionen undEndpunkte in der Allgemeinen AWS-Referenz.

2. Wählen Sie auf der Seite AWS CodeStar die Option Create a new project (Neues Projekt erstellen).(Wenn Sie der erste Benutzer sind, der ein Projekt erstellt, wählen Sie Start a project (Starten einesProjekts).)

3. Wählen Sie auf der Seite Choose a project template (Wählen einer Projektvorlage) aus der Listevon Projektvorlagen für AWS CodeStar die Art des Projekts aus. Sie können die Auswahl mithilfeder Filterleiste eingrenzen. Zum Beispiel: Markieren Sie für eine Webanwendung in Node.js, diefür Amazon EC2-Instances bereitgestellt werden soll, die Kontrollkästchen Web application (Web-Anwendung), Node.js und Amazon EC2. Wählen Sie dann aus den Vorlagen für diese Optionen aus.

Weitere Informationen finden Sie unter AWS CodeStar-Projektvorlagen (p. 41).4. Geben Sie unter Project name (Projektname) einen Namen für das Projekt ein, etwa Mein erstes

Projekt. Die ID für das Projekt wird aus diesem Projektnamen abgeleitet, ist jedoch auf 15 Zeichenbeschränkt.

Beispielsweise ist die Standard-ID für ein Projekt mit dem Namen Mein erstes Projekt „my-first-projec“. Diese Projekt-ID ist die Grundlage für die Namen aller mit dem Projekt verbundenenRessourcen. AWS CodeStar verwendet diese Projekt-ID als Teil der URL für Ihr Code-Repositoryund für die Namen der zugehörigen Rollen und Richtlinien für den Sicherheitszugriff in IAM. Nach derErstellung des Projekts kann die Projekt-ID nicht mehr geändert werden. Wählen Sie zur Bearbeitungder Projekt-ID vor der Erstellung des Projekts die Option Edit (Bearbeiten).

Informationen zu den Einschränkungen für Projektnamen und Projekt-IDs finden Sie unterEinschränkungen in AWS CodeStar (p. 145).

49




AWS CodeStar BenutzerhandbuchErstellen eines Projekts in AWS CodeStar (Konsole)

Note

Projekt-IDs für Ihr AWS-Konto müssen innerhalb einer AWS-Region eindeutig sein.5. Wählen Sie die Repository-Anbieter AWS CodeCommit oder GitHub.6. Wenn Sie AWS CodeCommit als Repository name (Repository-Namen) wählen, übernehmen Sie den

Standardnamen des AWS CodeCommit-Repository, oder geben Sie einen anderen Namen ein. FahrenSie dann mit Schritt 8 fort.

7. Wenn Sie GitHub gewählt haben, wählen Sie Connect with GitHub (Mit GitHub verbinden).

1. Wenn die Seite Sign in to GitHub (Bei GitHub anmelden) angezeigt wird, geben Sie Ihren GitHub-Benutzernamen oder die E-Mail-Adresse und das Passwort ein, und wählen Sie dann Sign in(Anmelden).

Note

Sie müssen über ein GitHub-Konto verfügen, um diese Seite auszufüllen. WeitereInformationen finden Sie unter Join GitHub Jenkins auf der GitHub-Website.

2. Wenn die Seite für die Two-factor authentication (Zwei-Faktor-Authentifizierung) angezeigt wird,geben Sie für Authentication code (Authentifizierungscode) den Code ein, den GitHub Ihnen sendet,und wählen Sie dann Verify (Überprüfen).

3. Wählen Sie auf der Seite Authorize AWS CodeStar (AWS CodeStar genehmigen) die OptionAuthorize application (Anwendung genehmigen).

Note

Wenn Sie die Option Authorize (Genehmigen) wählen, erlauben Sie AWS CodeStarein GitHub-Repository für Ihr persönliches GitHub-Konto zu erstellen, oder für einebeliebige GitHub-Organisation, wo Sie über Berechtigungen verfügen. (Ein grünesHäkchen in Organization access (Organisationszugriff) wird verwendet, um Berechtigungenanzugeben.)Um eine GitHub-Organisation zur Liste Organization access (Organisationszugang)hinzuzufügen, folgen Sie den Anweisungen unter Benutzer einladen, Ihrer Organisationbeizutreten auf der GitHub Help-Website. Nachdem Sie der Organisation beigetreten sind,aktualisieren Sie die Seite Authorize AWS CodeStar (AWS CodeStar genehmigen), um dieOrganisation in der Liste anzuzeigen.Um Berechtigungen für die Autorisierung einer GitHub-Organisation zu erhalten, die sichin der Liste befindet, aber keinen grünen Haken hat, wählen Sie Grant (Gestatten). WennSie stattdessen Request (Anfordern) sehen, wählen Sie es aus und folgen Sie dann denAnweisungen unter Genehmigen von OAuth-Apps für Ihre Organisation auf der GitHubHelp-Website. Aktualisieren Sie die Seite Authorize AWS CodeStar (AWS CodeStargenehmigen), um die Schaltfläche Grant (Genehmigen) anzuzeigen.

4. Für Owner (Besitzer) wählen Sie die GitHub-Organisation oder Ihr privates GitHub-Konto.5. Für Repository name (Repository-Name) übernehmen Sie den Standardnamen des GitHub-

Repository, oder geben Sie einen anderen Namen ein.6. Wählen Sie Public repository (Öffentliches Repository) oder Private repository (Privates Repository).

Note

Abhängig vom Typ Ihres GitHub-Kontos gestattet Ihnen GitHub Ihnen möglicherweisenicht, ein privates Repository zu erstellen. Weitere Informationen finden Sieunter GitHub Pricing auf der GitHub-Website. Wenn Sie AWS Cloud9 ebenso alsEntwicklungsumgebung verwenden möchten, müssen Sie ein öffentliches Repositoryauswählen.

7. (Optional) Für Repository description geben Sie eine Beschreibung für das GitHub-Repository ein.8. Wählen Sie Next.

50

https://github.com/join



https://help.github.com/articles/approving-oauth-apps-for-your-organization/

https://github.com/pricing

AWS CodeStar BenutzerhandbuchErstellen eines Projekts in AWS CodeStar (AWS CLI)

9. Überprüfen Sie die Ressourcen und Konfigurationsdetails. Wählen Sie Edit Amazon EC2 Configuration(Amazon EC2-Konfiguration bearbeiten) (falls verfügbar), wenn Ihr Projekt für Amazon EC2-Instancesbereitgestellt ist und Sie Änderungen vornehmen möchten. Sie können beispielsweise aus denverfügbaren Instance-Typen für Ihr Projekt eine Auswahl treffen.

Note

Unterschiedliche Amazon EC2-Instance-Typen bieten ein unterschiedliches Maß anRechenleistung und können mit unterschiedlichen Kosten verbunden sein. WeitereInformationen finden Sie unter Amazon EC2-Instance-Typen und Amazon EC2-Preise.Wenn Sie mehr als eine Virtual Private Cloud (VPC) oder mehrere Subnetze in AmazonVirtual Private Cloud erstellt haben, können Sie die VPC und das Subnetz zur Verwendungauswählen. Wenn Sie jedoch einen Amazon EC2-Instance-Typ wählen, der auf DedicatedInstances nicht unterstützt wird, können Sie keine VPC wählen, deren Instance-Tenancy aufDedicated (Dediziert) gesetzt ist.Weitere Informationen finden Sie unter Was ist Amazon VPC? und Dedicated Instance –Grundlagen.

10. Lassen Sie das Kontrollkästchen AWS CodeStar would like permission to administer AWS resourceson your behalf (AWS CodeStar möchte die Erlaubnis, AWS-Ressourcen in Ihrem Namen zu verwalten)ausgewählt. Andernfalls können Sie kein Projekt erstellen. Weitere Informationen über die Service-Rolle finden Sie unter Richtlinie und Berechtigungen für die AWS CodeStar Service-Rolle (p. 117).

Wählen Sie Next (Weiter) oder Create project (Projekt erstellen). (Die angezeigte Wahlmöglichkeithängt von Ihrer Projektvorlage ab.)

11. Wählen Sie unter Choose an Amazon EC2 Key Pair (Ein Amazon EC2-Schlüsselpaar auswählen)das Amazon EC2-Schlüsselpaar, das Sie in Schritt 4:Erstellen eines Amazon EC2-Schlüsselpaarsfür AWS CodeStar-Projekte (p. 5) erstellt haben. Wählen Sie I acknowledge that I have access to theprivate key file for this key pair (Ich bestätige, dass ich Zugriff auf die private Schlüsseldatei für diesesSchlüsselpaar habe) und dann Create project (Projekt erstellen).

12. Das Erstellen des Projekts (einschließlich des Repositorys) kann einige Minuten dauern. SobaldIhr Projekt ein Repository hat, können Sie auf der Seite Set up tools (Tools einrichten) den Zugriffdarauf konfigurieren. Sie können auch Skip (Überspringen) wählen, um diese Konfiguration spätervorzunehmen. Nachdem Ihr Projekt erstellt wurde, können Sie die Links auf der Kachel Welcome(Willkommen) verwenden, um andere Elemente zu konfigurieren, wie z.B. Ihr Benutzerprofil in AWSCodeStar (p. 105).


Erstellen eines Projekts in AWS CodeStar (AWS CLI)Ein AWS CodeStar Projekt ist eine Kombination aus Quellcode und erstellten Ressourcen, um den Codebereitzustellen. Die Sammlung von Ressourcen, die Ihnen bei der Erstellung, Freigabe und BereitstellungIhres Codes helfen, werden Toolchain-Ressourcen genannt. Bei der Projekterstellung stellt eine AWSCloudFormation-Vorlage Ihre Toolchain-Ressourcen in einer CI/CD-Pipeline (Continuous Integration/Continuous Deployment) bereit.

Wenn Sie die Konsole zum Erstellen eines Projekts verwenden, wird die Toolchain-Vorlage für Sie erstellt.Wenn Sie die AWS CLI zum Erstellen eines Projekts verwenden, erstellen Sie die Toolchain-Vorlage, dieIhre Toolchain-Ressourcen erstellt.

Eine vollständige Toolchain benötigt die folgenden empfohlenen Ressourcen:

1. Ein CodeCommit- oder GitHub-Repository, das Ihren Quellcode enthält.2. Eine CodePipeline-Pipeline, die zum Verfolgen von Änderungen an Ihrem Repository konfiguriert ist.

51

https://aws.amazon.com/ec2/instance-types/

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

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Introduction.html




a. Wenn Sie CodeBuild verwenden, um Komponenten- oder Integrationstests durchzuführen, empfehlenwir Ihnen, Ihrer Pipeline eine Build-Stage hinzuzufügen, um Build-Artefakte zu erstellen.

b. Wir empfehlen Ihnen, Ihrer Pipeline eine Bereitstellungsphase hinzuzufügen, die CodeDeployoder AWS CloudFormation verwendet, um Ihr Build-Artefakt und Ihren Quellcode in IhrerLaufzeitinfrastruktur bereitzustellen.

Note

Da CodePipeline mindestens zwei Stufen in einer Pipeline erfordert und die erste Stufe dieQuellstufe sein muss, fügen Sie eine Build- oder eine Bereitstellungsstufe als zweite Stufehinzu.

AWS CodeStar-Toolchains sind definiert als CloudFormation-Vorlage.

Ein Tutorial mit einer Schritt-für-Schritt-Anleitung durch diese Aufgabe und Beispiel-Ressourcen finden Sieunter Tutorial: Erstellen eines Projekts in AWS CodeStar mit der AWS CLI (p. 31).

Voraussetzungen:

Wenn Sie ein Projekt anlegen, geben Sie die folgenden Parameter in einer Eingabedatei an. Wenn diefolgenden Angaben nicht gemacht werden, erstellt AWS CodeStar ein leeres Projekt.

• Quellcode Wenn dieser Parameter in Ihrer Anfrage enthalten ist, müssen Sie auch eine Toolchain-Vorlage einbinden.• Ihr Quellcode muss den Anwendungscode enthalten, der für die Ausführung Ihres Projekts erforderlich

ist.• Ihr Quellcode muss alle erforderlichen Konfigurationsdateien enthalten, wie beispielsweise eine

buildspec.yml für ein CodeBuild-Projekt oder eine appspec.yml für eine CodeDeploy-Bereitstellung.• Sie können optionale Elemente in Ihren Quellcode aufnehmen, wie z.B. ein README oder eine

template.yml für Nicht-Toolchain-AWS-Ressourcen.• Toolchain-Vorlage. Ihre Toolchain-Vorlage enthält die für Ihr Projekt zu verwaltenden AWS-Ressourcen

und IAM-Rollen.• Quellenstandorte Wenn Sie Quellcode und eine Toolchain-Vorlage für Ihr Projekt festlegen, müssen Sie

einen Speicherort angeben. Laden Sie Ihre Quelldateien und Ihre Toolchain-Vorlage in den Amazon S3-Bucket hoch. AWS CodeStar ruft die Dateien ab und verwendet sie zur Erstellung des Projekts.

Important

Stellen Sie sicher, dass Sie die bevorzugte AWS-Region in der AWS CLI konfigurieren. Ihr Projektwird in der AWS-Region angelegt, die in der AWS CLI konfiguriert ist.

1. Führen Sie den Befehl create-project aus und beziehen Sie den --generate-cli-skeleton-Parameter ein.

aws codestar create-project --generate-cli-skeleton

Daten im JSON-Format werden in der Ausgabe angezeigt. Kopieren Sie die Daten in eine Datei (z. B.input.json) auf Ihrem lokalen Computer oder auf einer Instance, auf der AWS CLI installiert ist.Ändern Sie die kopierten Daten wie im Folgenden dargestellt und speichern Sie die Ergebnisse.

{ "name": "project-name", "id": "project-id", "description": "description", "sourceCode": [ {

52

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html


"source": { "s3": { "bucketName": "s3-bucket-name", "bucketKey": "s3-bucket-object-key" } }, "destination": { "codeCommit": { "name": "codecommit-repository-name" }, "gitHub": { "name": "github-repository-name", "description": "github-repository-description", "type": "github-repository-type", "owner": "github-repository-owner", "privateRepository": true, "issuesEnabled": true, "token": "github-personal-access-token" } } } ], "toolchain": { "source": { "s3": { "bucketName": "s3-bucket-name", "bucketKey": "s3-bucket-object-key" } }, "roleArn": "service-role-arn", "stackParameters": { "KeyName": "key-name" } }, "tags": { "KeyName": "key-name" }}

Ersetzen Sie Folgendes:

• project-name: erforderlich. Der benutzerfreundliche Name für dieses AWS CodeStar-Projekt.• project-id: erforderlich. Die Projekt-ID für dieses AWS CodeStar-Projekt.

Note

Sie müssen eine eindeutige Projekt-ID angeben, wenn Sie ein Projekt erstellen. Sieerhalten eine Fehlermeldung, wenn Sie eine Eingabedatei mit einer bereits vorhandenenProjekt-ID einreichen.

• description: optional. Die Beschreibung für dieses AWS CodeStar-Projekt.• sourceCode: optional. Die Konfigurationsinformationen für den für das Projekt bereitgestellten

Quellcode. Derzeit wird nur ein einzelnes sourceCode-Objekt unterstützt. Jedes sourceCode-Objekt enthält Informationen über den Ort, von dem der Quellcode von AWS CodeStar abgerufenwird, und das Ziel, an dem der Quellcode eingepflegt wird.• source (erforderlich). Dies legt den Speicherort fest, an dem Sie Ihren Quellcode hochgeladen

haben. Die einzige unterstützte Quelle ist Amazon S3. AWS CodeStar ruft den Quellcode ab undnimmt ihn nach der Erstellung Ihres Projekts in das Repository auf.• S3: optional. Der Amazon S3-Speicherort Ihres Quellcodes.

• bucket-name: Der Bucket, der Ihren Quellcode enthält.

53


• bucket-key: Das Bucket-Präfix und der Objektschlüssel, der auf die.zip-Datei verweist, dieIhren Quellcode enthält (z.B. src.zip).

• destination: optional. Die Zielorte, an denen Ihr Quellcode beim Erstellen des Projektseingebunden werden soll. Die unterstützten Ziele für Ihren Quellcode sind CodeCommit undGitHub.

Sie können nur eine dieser beiden Optionen angeben:• codeCommit: Das einzige erforderliche Attribut ist der Name des CodeCommit-Repository,

das Ihren Quellcode enthalten soll. Dieses Repository sollte sich in Ihrer Toolchain-Vorlagebefinden.

Note

Für CodeCommit müssen Sie den Namen des Repository angeben, das Sie in IhremToolchain-Stapel definiert haben. AWS CodeStar initialisiert dieses Repository mit demQuellcode, den Sie in Amazon S3 angegeben haben.

• gitHub: Dieses Objekt stellt Informationen dar, die benötigt werden, um das GitHub-Repositoryzu erstellen und es mit Quellcode zu versehen. Wenn Sie ein GitHub-Repository wählen, sinddie folgenden Werte erforderlich.

Note

Für GitHub können Sie kein bestehendes GitHub-Repository angeben. AWS CodeStarerstellt eines für Sie und füllt dieses Repository mit dem Quellcode, den Sie in AmazonS3 hochgeladen haben. AWS CodeStar verwendet die folgenden Informationen, um IhrRepository in GitHub zu erstellen.

• name: erforderlich. Der Name Ihres GitHub-Repository.• description: erforderlich. Der Beschreibung von Ihrem GitHub-Repository.• type: erforderlich. Der Typ des GitHub-Repository. Gültige Werte sind Benutzer oder die

Organisation.• owner: erforderlich. Der GitHub-Benutzername für den Eigentümer Ihres Repositorys. Wenn

das Repository im Besitz einer GitHub-Organisation sein soll, geben Sie den Namen derOrganisation an.

• privateRepository: erforderlich. Ob Sie möchten, dass dieses Repository privat oderöffentlich ist. Gültige Werte sind true oder false.

• issuesEnabled: erforderlich. Ob Sie Elemente in GitHub mit diesem Repository aktivierenmöchten. Gültige Werte sind true oder false.

• token: erforderlich. Dies ist ein persönlicher Zugriffstoken, mit dem AWS CodeStar auf IhrGitHub-Konto zugreift. Dieser Token muss die folgenden Bereiche enthalten: repo, user undadmin:repo_hook. Informationen zum Abrufen eines persönlichen Zugriffstokens von GitHubfinden Sie unter Creating a Personal Access Token for the Command Line auf der GitHub-Website.

• toolchain: Informationen über die CI/CD-Toolchain, die beim Anlegen des Projektseingerichtet werden soll. Dazu gehört der Speicherort, an dem Sie die Toolchain-Vorlagehochgeladen haben. Die Vorlage erstellt den AWS CloudFormation-Stack, in dem IhreToolchain-Ressourcen enthalten sind. Dazu gehören auch alle zu referenzierendenParameterüberschreibungen für AWS CloudFormation und die Rolle, die zum Erstellen desStapels verwendet werden soll. AWS CodeStar ruft die Vorlage ab und verwendet AWSCloudFormation zum Ausführen der Vorlage.• source (erforderlich). Der Speicherort Ihrer Toolchain-Vorlage. Amazon S3 ist der einzige

unterstützte Quellspeicherort.• S3: optional. Der Amazon S3-Speicherort, an dem Sie Ihre Toolchain-Vorlage hochgeladen

haben.• bucket-name: Der Amazon S3 Bucket-Name.

54

https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/


• bucket-key: Das Bucket-Präfix und der Objektschlüssel, der auf die .yml- oder .json-Datei verweist, die Ihre Toolchain-Vorlage enthält (z.B. files/toolchain.yml).

• stackParameters: optional. Enthält Schlüssel-Wert-Paare, die an AWS CloudFormationübergeben werden sollen. Dies sind die Parameter, falls vorhanden, ist Ihre Toolchain-Vorlage als Referenz eingerichtet.

• role: optional. Die Rolle, mit der Sie Ihre Toolchain-Ressourcen in Ihrem Konto anlegen. DieRolle ist wie folgt erforderlich:• Wenn die Rolle nicht angegeben wird, verwendet AWS CodeStar die Standard-Service-

Rolle, die für Ihr Konto erstellt wird, wenn die Toolchain eine AWS CodeStar-Schnellstart-Vorlage ist. Wenn die Servicerolle in Ihrem Konto nicht vorhanden ist, können Sie eineerstellen. Weitere Informationen finden Sie unter Schritt 2: Erstellen der AWS CodeStar-Servicerolle (p. 3).

• Sie müssen die Rolle bereitstellen, wenn Sie beim Hochladen Ihre eigenebenutzerdefinierte Toolchain-Vorlage verwenden. Sie können eine Rolle basierendauf der AWS CodeStar-Service-Rolle und Richtlinienanweisung erstellen. Ein Beispielfür diese Richtlinienanweisung finden Sie unter AWS CodeStar-Richtlinie für dieServicerolle (p. 122).

• tags: optional. Die Tags, die an Ihr AWS CodeStar-Projekt angefügt sind.

Note

Diese Tags sind nicht an die im Projekt enthaltenen Ressourcen gebunden.2. Wechseln Sie in das Verzeichnis, das die soeben gespeicherte Datei enthält, und führen Sie den

Befehl create-project erneut aus. Schließen Sie den Parameter --cli-input-json ein.

aws codestar create-project --cli-input-json file://input.json

3. Ist der Befehl erfolgreich, gibt er als Ausgabe Daten zurück, die wie folgt aussehen sollten:

{ "id": "project-ID", "arn": "arn"}

• Die Ausgabe enthält Informationen über das neue Projekt:• Der Wert id repräsentiert die Projekt-ID.• Der Wert arn zeigt den ARN des Projekts an.

4. Verwenden Sie den Befehl describe-project, um den Status Ihrer Projekterstellung zu überprüfen.Schließen Sie den Parameter --id ein.

aws codestar describe-project --id <project_ID>

In der Ausgabe erscheinen ähnliche Daten wie die folgenden:

{ "name": "MyProject", "id": "myproject", "arn": "arn:aws:codestar:us-east-1:account_ID:project/myproject", "description": "", "createdTimeStamp": 1539700079.472, "stackId": "arn:aws:cloudformation:us-east-1:account_ID:stack/awscodestar-myproject/stack-ID", "status": { "state": "CreateInProgress" }

55

AWS CodeStar BenutzerhandbuchVerwenden einer IDE für AWS CodeStar

}

• Die Ausgabe enthält Informationen über das neue Projekt:• Der Wert state stellt den Status der Projekterstellung dar, z.B. CreateInProgress oderCreateComplete.


Verwenden einer IDE für AWS CodeStarWenn Sie eine IDE in AWS CodeStar integrieren, können Sie weiterhin Code in Ihrer bevorzugtenUmgebung schreiben und entwickeln. Die Änderungen, die Sie vornehmen, werden bei jeder Bestätigungund Weiterleitung Ihres Codes in das AWS CodeStar-Projekt aufgenommen.

Themen• AWS Cloud9 und AWS CodeStar (p. 57)• Verwenden von Eclipse für AWS CodeStar (p. 62)• Visual Studio und AWS CodeStar (p. 66)

56

AWS CodeStar BenutzerhandbuchAWS Cloud9 und AWS CodeStar

AWS Cloud9 und AWS CodeStarMit AWS Cloud9 können Sie in einem AWS CodeStar-Projekt Codeänderungen vornehmen und Softwareentwickeln. AWS Cloud9 ist eine Online-IDE, auf die Sie über Ihren Webbrowser zugreifen können. Die IDEbietet eine umfassende Codebearbeitung mit Unterstützung mehrerer Programmiersprachen und Runtime-Debugger sowie ein integriertes Terminal. Im Hintergrund befindet sich in einer Amazon EC2-Instanz eineAWS Cloud9-Entwicklungsumgebung. Diese Umgebung stellt die AWS Cloud9-IDE und den Zugriff aufdie AWS CodeStar-Codedateien des Projekts zur Verfügung. Weitere Informationen finden Sie im AWSCloud9-Benutzerhandbuch.

Sie können die AWS CodeStar-Konsole oder die AWS Cloud9-Konsole verwenden, um AWS Cloud9-Entwicklungsumgebungen für Projekte zu erstellen, die ihren Code in CodeCommit speichern. FürAWS CodeStar-Projekte, die ihren Code in GitHub speichern, können Sie nur die AWS Cloud9-Konsoleverwenden. In diesem Thema wird beschrieben, wie Sie die beiden Konsolen verwenden.

Um AWS Cloud9 zu verwenden, benötigen Sie Folgendes:

• Einen IAM-Benutzer, der einem AWS CodeStar-Projekt als Teammitglied hinzugefügt wurde.• Wenn das AWS CodeStar-Projekt seinen Quellcode in CodeCommit speichert, die AWS-

Anmeldeinformationen für den IAM-Benutzer.

Themen• Erstellen Sie eine AWS Cloud9-Umgebung für ein Projekt (p. 57)• Öffnen einer AWS Cloud9-Umgebung für ein Projekt (p. 59)• Freigeben einer AWS Cloud9-Umgebung für ein Projekt-Teammitglied (p. 60)• Löschen einer AWS Cloud9-Umgebung von einem Projekt (p. 61)• Verwenden von GitHub mit AWS Cloud9 (p. 61)• Weitere Ressourcen (p. 62)

Erstellen Sie eine AWS Cloud9-Umgebung für ein ProjektFühren Sie die folgenden Schritte aus, um eine AWS Cloud9-Entwicklungsumgebung für ein AWSCodeStar-Projekt zu erstellen.

Vorhandenes AWS CodeStar-Projekt

Öffnen Sie das Projekt in der AWS CodeStar-Konsole. Wählen Sie auf der seitlichen NavigationsleisteIDE. Wählen Sie Create new environment (Neue Umgebung erstellen) und führen Sie dann die folgendenSchritte aus.

Important

Wenn der Quellcode des Projekts in GitHub gespeichert ist, wird die IDE auf der seitlichenNavigationsleiste nicht angezeigt. Allerdings können Sie die AWS Cloud9 Konsole verwenden, umeine Entwicklungsumgebung zu erstellen, öffnen Sie die neue Umgebung, und stellen Sie eineVerbindung mit dem GitHub-Repository des Projekts her. Überspringen Sie die folgenden Schritteund gehen Sie zu Verwenden von GitHub mit AWS Cloud9 (p. 61).Wenn sich das Projekt in einer AWS-AWS Region befindet, in der AWS Cloud9 nicht unterstütztwird, wird die IDE in der seitlichen Navigationsleiste nicht angezeigt. Allerdings können Sie dieAWS Cloud9-Konsole verwenden, um eine Entwicklungsumgebung zu erstellen, öffnen Siedie neue Umgebung, und stellen Sie eine Verbindung mit dem AWS CodeCommit-Repositorydes Projekts her. Überspringen Sie die folgenden Schritte und lesen Sie im AWS Cloud9-Benutzerhandbuch die Abschnitte Erstellen einer Umgebung, Öffnen einer Umgebung und dasAWS CodeCommit-Beispiel. Eine Liste der unterstützten AWS-Regionen finden Sie unter AWSCloud9 im Allgemeine Amazon Web Services-Referenz.

57

http://docs.aws.amazon.com/cloud9/latest/user-guide/

http://docs.aws.amazon.com/cloud9/latest/user-guide/

http://docs.aws.amazon.com/cloud9/latest/user-guide/create-environment.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/open-environment.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/sample-codecommit.html

https://docs.aws.amazon.com/general/latest/gr/rande.html#cloud9_region



Neues AWS CodeStar-Projekt

Führen Sie die Schritte unter Erstellen eines Projekts (p. 49) aus. Wählen Sie unter Set up tools (Toolseinrichten) fürPick how you want to edit your code (Wählen Sie aus, wie Sie Ihren Code bearbeitenmöchten) den Eintrag Cloud9. Wählen Sie Next (Weiter) und führen Sie dann die folgenden Schritte aus.

Important

Wenn Sie sich dafür entscheiden, den Quellcode des Projekts in GitHub zu speichern, sehenSie auf der Seite Set up tools (Tools einrichten) anstelle von Pick how you want to edit your code(Wählen Sie aus, wie Sie Ihren Code bearbeiten möchten), Connect to your source repository(Verbindung zu Ihrem Quell-Repository herstellen). Hier gibt es keine Option AWS Cloud9.Allerdings können Sie, nachdem AWS CodeStar das Projekt erstellt hat, die AWS Cloud9- Konsoleverwenden, um eine Entwicklungsumgebung erstellen und öffnen und diese dann mit dem GitHub-Repository des Projekts verbinden. Überspringen Sie die folgenden Schritte und gehen Sie zuVerwenden von GitHub mit AWS Cloud9 (p. 61).Wenn sich das Projekt in einer AWS-Region befindet, die von AWS Cloud9 nicht unterstütztwird, finden Sie auf Set up tools (Tools einrichten) keine Option AWS Cloud9 zum Auswählen.Allerdings können Sie die AWS Cloud9-Konsole verwenden, um eine Entwicklungsumgebungzu erstellen und zu öffnen und sie dann mit dem AWS CodeCommit-Repository des Projektszu verbinden. Überspringen Sie die folgenden Schritte und lesen Sie im AWS Cloud9-Benutzerhandbuch die Abschnitte Erstellen einer Umgebung, Öffnen einer Umgebung und dasAWS CodeCommit-Beispiel. Eine Liste der unterstützten AWS-Regionen finden Sie unter AWSCloud9 im Allgemeine Amazon Web Services-Referenz.

Passen Sie unter Set up your AWS Cloud9 environment (Einrichten Ihrer AWS Cloud9-Umgebung) dieStandardeinstellungen für das Projekt an.

1. Um den Standardtyp der Amazon EC2-Instance für das Hosten der Umgebung zu ändern, wählenSie für Pick a instance type for the IDE (Wählen Sie einen Instance-Typ für die IDE) (nicht IhrGesamtprojekt) den Instance-Typ.

2. Um den Standard-Umgebungsnamen zu ändern und eine Beschreibung hinzuzufügen, erweitern SieEnvironment name and description (Umgebungsname und Beschreibung), und nehmen Sie dann IhreÄnderungen vor.

Note

Der Umgebungsname muss für den Benutzer eindeutig sein.3. AWS Cloud9 verwendet Amazon Virtual Private Cloud (Amazon VPC) im AWS-Konto für die

Kommunikation mit der Instance. Je nachdem, wie Amazon VPC in Ihrem AWS-Konto eingerichtet ist,führen Sie einen der folgenden Schritte aus.

Verfügtdas Kontoüber eineVPC mitmindestenseinemSubnetzin dieserVPC?

Ist die VPC,die AWSCloud9verwendensoll, dieStandard-VPC imKonto?

Hat dieVPC eineinzelnesSubnetz?

Vorgehensweise

Nein — — Wenn keine VPC vorhanden ist, erstellen Sie eine.Erweitern Sie Network settings (Netzwerkeinstellungen).Wählen Sie für Network (VPC) (Netzwerk (VPC))die Option Create VPC (VPC erstellen) aus undfolgen Sie dann den Anweisungen auf der Seite.

58



http://docs.aws.amazon.com/cloud9/latest/user-guide/sample-codecommit.html




Verfügtdas Kontoüber eineVPC mitmindestenseinemSubnetzin dieserVPC?

Ist die VPC,die AWSCloud9verwendensoll, dieStandard-VPC imKonto?

Hat dieVPC eineinzelnesSubnetz?

Vorgehensweise

Weitere Informationen finden Sie unter Erstelleneines Amazon VPC für AWS Cloud9 im AWS Cloud9Benutzerhandbuch.

Wenn eine VPC vorhanden ist, die jedoch kein Subnetzhat, erstellen Sie eines. Erweitern Sie Network settings(Netzwerkeinstellungen). Wählen Sie für Network (VPC)(Netzwerk (VPC)) die Option Create subnet (Subnetzerstellen) aus und folgen Sie den Anweisungen.Weitere Informationen finden Sie unter Erstelleneines Subnetzes für AWS Cloud9 im AWS Cloud9Benutzerhandbuch.

Ja Ja Ja Gehen Sie direkt zu Schritt 4 in diesem Verfahren.(AWS Cloud9 verwendet die Standard-VPC mit ihremeinzelnen Subnetz.)

Ja Ja Nein Erweitern Sie Network settings (advanced)(Netzwerkeinstellungen (erweitert)). Wählen Sie fürSubnet (Subnetz) das Subnetz aus, das AWS Cloud9 inder vorausgewählten Standard-VPC verwenden soll.

Ja Nein Sie könnenzwischenYes und Nowählen

Erweitern Sie Network settings (Netzwerkeinstellungen).Wählen Sie für Network (VPC) (Netzwerk (VPC)) dieVPC aus, die AWS Cloud9 verwenden soll. Wählen Siefür Subnet (Subnetz) das Subnetz aus, das AWS Cloud9in dieser VPC verwenden soll.

Weitere Informationen finden Sie unter Amazon VPC-Einstellungen für AWS Cloud9-Entwicklungsumgebungen im AWS Cloud9-Benutzerhandbuch.

4. Um den Standardzeitraum zu ändern, nach dem AWS Cloud9 die Umgebung herunterfährt, wenn sienicht verwendet wurde, erweitern Sie Cost saving options (Kosteneinsparungsoptionen), und ändernSie dann die Einstellung.

5. Wählen Sie Next.

Um die Umgebung zu öffnen, siehe Öffnen einer AWS Cloud9-Umgebung für ein Projekt (p. 59).

Mit diesen Schritten können Sie mehr als eine Umgebung für ein Projekt anlegen. Beispielsweise könnenSie eine Umgebung verwenden, um an einem Teil des Codes zu arbeiten, und eine andere Umgebung, uman demselben Teil des Codes mit unterschiedlichen Einstellungen zu arbeiten.

Öffnen einer AWS Cloud9-Umgebung für ein ProjektFühren Sie die folgenden Schritte aus, um eine AWS Cloud9-Entwicklungsumgebung, die Sie für ein AWSCodeStar-Projekt erstellt haben, zu öffnen.

59

http://docs.aws.amazon.com/cloud9/latest/user-guide/vpc-settings.html#vpc-settings-create-vpc

http://docs.aws.amazon.com/cloud9/latest/user-guide/vpc-settings.html#vpc-settings-create-vpc

http://docs.aws.amazon.com/cloud9/latest/user-guide/vpc-settings.html#vpc-settings-create-subnet

http://docs.aws.amazon.com/cloud9/latest/user-guide/vpc-settings.html#vpc-settings-create-subnet

http://docs.aws.amazon.com/cloud9/latest/user-guide/vpc-settings.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/vpc-settings.html


1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im seitlichen NavigationsfensterIDE.

Important

Wenn der Quellcode des Projekts in GitHub gespeichert ist, wird die IDE auf der seitlichenNavigationsleiste nicht angezeigt. Sie können die AWS Cloud9-Konsole jedoch verwenden,um eine vorhandene Umgebung zu öffnen. Überspringen Sie den Rest dieses Verfahrens undgehen Sie zu Öffnen einer Umgebung im AWS Cloud9-Benutzerhandbuch und Verwendenvon GitHub mit AWS Cloud9 (p. 61).

2. Für Your AWS Cloud9 environments (Ihre AWS Cloud9-Umgebungen) oder Shared AWS Cloud9environments (Geteilte AWS Cloud9-Umgebungen), wählen Sie Open IDE (IDE öffnen) für dieUmgebung, die Sie öffnen möchten.

Mit der AWS Cloud9-IDE können Sie sofort mit der Arbeit mit Code im AWS CodeCommit-Repositorydes Projekts beginnen. Weitere Informationen finden Sie unter Das Umgebungsfenster, Der Editor,die Registerkarten und die Bereiche, und Das Terminal in der AWS Cloud9-Benutzerhandbuch undGrundlegende Git-Befehle im AWS CodeCommit-Benutzerhandbuch.

Freigeben einer AWS Cloud9-Umgebung für ein Projekt-TeammitgliedNachdem Sie eine AWS Cloud9-Entwicklungsumgebung für ein AWS CodeStar-Projekt erstellt haben,können Sie andere Benutzer, einschließlich der Mitglieder des Projektteams, über Ihr AWS-Konto einladen,auf dieselbe Umgebung zuzugreifen. Dies ist besonders nützlich für die Paarprogrammierung, bei derzwei Programmierer abwechselnd kodieren und Ratschläge zum gleichen Code geben, indem sie denBildschirm teilen oder am selben Arbeitsplatz sitzen. Umgebungsmitglieder können die gemeinsame AWSCloud9-IDE verwenden, um die Code-Änderungen jedes Mitglieds im Code-Editor hervorgehoben zu sehenund während der Codierung Text-Chat mit anderen Mitgliedern zu führen.

Das Hinzufügen eines Teammitglieds zu einem Projekt erlaubt es diesem nicht automatisch,an zugehörigen AWS Cloud9-Entwicklungsumgebungen für das Projekt teilzunehmen. Um einProjektteammitglied zum Zugriff auf eine Umgebung für ein Projekt einzuladen, müssen Sie die richtigeRolle für den Zugriff von Umgebungsmitgliedern festlegen, die AWS-verwalteten Richtlinien auf denBenutzer anwenden und den Benutzer in Ihre Umgebung einladen. Weitere Informationen finden Sie unterÜber Umgebungsmitglieder-Zugriffsrollen und Einladen eines IAM-Benutzers in Ihre Umgebung im AWSCloud9-Benutzerhandbuch.

Wenn Sie ein Projektteammitglied einladen, auf eine Umgebung für ein Projekt zuzugreifen, zeigt die AWSCodeStar-Konsole diesem Teammitglied die Umgebung an. Die Umgebung wird in der Liste Shared Cloud9environments (Freigegebene Cloud9-Umgebungen) auf der Registerkarte IDE in der AWS CodeStar-Konsole für das Projekt angezeigt. Um diese Liste anzuzeigen, lassen Sie das Teammitglied das Projekt inder Konsole öffnen und dann IDE in der seitlichen Navigationsleiste auswählen.

Important

Wenn der Quellcode des Projekts in GitHub gespeichert ist, wird die IDE auf der seitlichenNavigationsleiste nicht angezeigt. Sie können jedoch die AWS Cloud9-Konsole verwenden, umandere Benutzer über Ihr AWS-Konto einzuladen, einschließlich Projektmitarbeiter, um auf eineUmgebung zuzugreifen. Um dies zu tun, siehe Verwenden von GitHub mit AWS Cloud9 (p. 61)in dieser Anleitung, und siehe Über Umgebungsmitglieder-Zugriffsrollen und Einladen eines IAM-Benutzers in Ihre Umgebung im AWS Cloud9-Benutzerhandbuch.

Sie können auch einen Benutzer, der kein Projektmitarbeiter ist, zum Zugriff auf eine Umgebungeinladen. Beispielsweise können Sie wollen, dass ein Benutzer an dem Code eines Projekts arbeitet,aber keinen anderen Zugriff auf dieses Projekt hat. Um diesen Benutzertyp einzuladen, siehe Über

60


http://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial.html#tutorial-environment

http://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial.html#tutorial-editor


http://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial.html#tutorial-terminal

https://docs.aws.amazon.com/codecommit/latest/userguide/how-to-basic-git.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/share-environment.html#share-environment-member-roles

http://docs.aws.amazon.com/cloud9/latest/user-guide/share-environment.html#share-environment-invite-user






Umgebungsmitglieder-Zugriffsrollen und Einladen eines IAM-Benutzers in Ihre Umgebung im AWS Cloud9-Benutzerhandbuch. Wenn Sie einen Benutzer einladen, der kein Projektteammitglied ist, um auf eineUmgebung für ein Projekt zuzugreifen, kann dieser Benutzer die AWS Cloud9-Konsole für den Zugriffauf die Umgebung verwenden. Weitere Informationen finden Sie unter Öffnen einer Umgebung im AWSCloud9-Benutzerhandbuch.

Löschen einer AWS Cloud9-Umgebung von einem ProjektWenn Sie ein Projekt und alle seine AWS-Ressourcen aus AWS CodeStar löschen, werden auch allezugehörigen AWS Cloud9-Entwicklungsumgebungen, die mit der AWS CodeStar-Konsole erstellt wurden,gelöscht und können nicht wiederhergestellt werden. Sie können eine Entwicklungsumgebung aus einemProjekt löschen, ohne das Projekt zu löschen.

1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im seitlichen NavigationsfensterIDE.

Important

Wenn der Quellcode des Projekts in GitHub gespeichert ist, wird die IDE auf der seitlichenNavigationsleiste nicht angezeigt. Sie können die AWS Cloud9-Konsole jedoch verwenden,um eine Entwicklungsumgebung zu löschen. Überspringen Sie den Rest dieses Verfahrensund gehen Sie zu Löschen einer Umgebung im AWS Cloud9-Benutzerhandbuch.

2. Wählen Sie auf der Kachel für die Umgebung, die Sie löschen möchten, die Ellipsen (…).3. Geben Sie den Namen für die Entwicklungsumgebung ein, und klicken Sie dann auf Delete (Löschen).

Warning

Sie können eine Entwicklungsumgebung nicht wiederhergestellt werden, nachdem siegelöscht wurde. Alle nicht bestätigten Code-Änderungen in der Umgebung gehen verloren.

Verwenden von GitHub mit AWS Cloud9Für AWS CodeStar-Projekte, die ihren Quellcode in GitHub gespeichert haben, unterstützt die AWSCodeStar Konsole keine direkte Arbeit mit AWS Cloud9-Entwicklungsumgebungen. Sie können jedoch dieAWS Cloud9-Konsole verwenden, um mit Quellcode in GitHub-Repositories zu arbeiten.

1. Verwenden Sie die AWS Cloud9-Konsole, um eine AWS Cloud9-Entwicklungsumgebung zu erstellen.Weitere Informationen finden Sie unter Erstellen einer Umgebung im AWS Cloud9-Benutzerhandbuch.

2. Verwenden Sie die AWS Cloud9-Konsole, um die Entwicklungsumgebung zu öffnen. WeitereInformationen finden Sie unter Öffnen einer Umgebung im AWS Cloud9-Benutzerhandbuch.

3. Verwenden Sie in der IDE eine Terminalsitzung, um sich mit dem GitHub-Repository zu verbinden (einProzess, der als cloning bekannt ist). Wenn keine Terminalsitzung ausgeführt wird, wählen Sie in derMenüleiste der IDE Window, New Terminal (Fenster, neues Terminal). Die Befehle zum Klonen desGitHub-Repositorys finden Sie unter Cloning a Repository auf der GitHub Help-Website.

Um zur Hauptseite des GitHub-Repositorys zu gelangen, wählen Sie bei geöffnetem Projekt in derAWS CodeStar-Konsole in der seitlichen Navigationsleiste Code.

4. Verwenden Sie das Fenster Environment (Umgebung) und die Editor-Registerkarten in derIDE, um Code anzuzeigen, zu ändern und zu speichern. Weitere Informationen finden Sie unterDas Umgebungsfenster und Der Editor, die Registerkarten und die Bereiche im AWS Cloud9-Benutzerhandbuch.

5. Verwenden Sie Git in der Terminalsitzung in der IDE, um weiterhin mehr Codeänderungen per Pushan das GitHub-Repository zu übertragen und um regelmäßig Codeänderungen anderer aus demRepository abzurufen. Weitere Informationen finden Sie unter Pushing to a Remote Respository undFetching a Remote Repository auf der GitHub Help-Website. Die Git-Befehle finden Sie unter GitCheatsheet auf der GitHub Help-Website.

61




http://docs.aws.amazon.com/cloud9/latest/user-guide/delete-environment.html



https://help.github.com/articles/cloning-a-repository/#platform-linux

http://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial.html#tutorial-environment


https://help.github.com/articles/pushing-to-a-remote/

https://help.github.com/articles/fetching-a-remote/

https://help.github.com/articles/git-cheatsheet/

https://help.github.com/articles/git-cheatsheet/

AWS CodeStar BenutzerhandbuchVerwenden von Eclipse für AWS CodeStar

Note

Um zu verhindern, dass Git Sie jedes Mal, wenn Sie Code aus dem Repository verschiebenoder holen, nach dem GitHub-Benutzernamen und dem Passwort fragt, können Sie einenCredential Helper verwenden. Weitere Informationen finden Sie unter Caching Your GitHubPassword in Git auf der GitHub Help-Website.

Weitere RessourcenWeitere Informationen zur Verwendung von AWS Cloud9 finden Sie im AWS Cloud9-Benutzerhandbuch.

• Praktische Anleitung• Arbeiten mit Umgebungen• Arbeiten mit der IDE• Beispiele

Verwenden von Eclipse für AWS CodeStarSie können Eclipse verwenden, um Code-Änderungen vorzunehmen und Software in einem AWSCodeStar-Projekt zu entwickeln. Sie können Ihren AWS CodeStar-Projekt-Code mit Eclipse bearbeiten unddann Ihre Änderungen bestätigen und an das Quell-Repository für das AWS CodeStar-Projekt übergeben.

Note

Die Informationen in diesem Thema gelten nur für AWS CodeStar-Projekte, die ihren Quellcode inCodeCommit speichern. Wenn Ihr AWS CodeStar-Projekt seinen Quellcode in GitHub speichert,können Sie ein Tool wie die EGit für Eclipse einsetzen. Weitere Informationen finden Sie unterEGit Documentation auf der EGit-Website.

Wenn das AWS CodeStar-Projekt seinen Quellcode in CodeCommit speichert, müssen Sie eine Versionvon AWS Toolkit for Eclipse installieren, die AWS CodeStar unterstützt. Sie müssen weiterhin ein Mitglieddes AWS CodeStar-Projektteams mit der Rolle Eigentümer oder Beitragsleistender sein.

Für die Verwendung von Eclipse brauchen Sie außerdem:

• Einen IAM-Benutzer, der einem AWS CodeStar-Projekt als Teammitglied hinzugefügt wurde.• Wenn das AWS CodeStar-Projekt seinen Quellcode in CodeCommit speichert, die Git-

Anmeldeinformationen (p. 12) (Benutzername und Passwort) für den IAM-Benutzer.• Ausreichende Berechtigungen für die Installation von Eclipse und AWS Toolkit for Eclipse auf Ihrem

lokalen Computer.

Themen• Schritt 1: Installieren von AWS Toolkit for Eclipse (p. 62)• Schritt 2: Importieren Ihres AWS CodeStar-Projekts in Eclipse (p. 63)• Schritt 3: Bearbeiten des AWS CodeStar-Project-Codes in Eclipse (p. 65)

Schritt 1: Installieren von AWS Toolkit for EclipseToolkit for Eclipse ist ein Softwarepaket, das Sie Eclipse hinzufügen können. Es wird genau so installiertund verwaltet wie andere Softwarepakete in Eclipse. Das AWS CodeStar-Toolkit ist Teil von Toolkit forEclipse.

62

https://help.github.com/articles/caching-your-github-password-in-git/

https://help.github.com/articles/caching-your-github-password-in-git/

http://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/environments.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/ide.html

http://docs.aws.amazon.com/cloud9/latest/user-guide/samples.html

http://www.eclipse.org/egit/documentation/


So installieren Sie Toolkit for Eclipse mit dem AWS CodeStar-Modul:

1. Installieren Sie Eclipse auf Ihrem lokalen Computer. Unterstützte Versionen von Eclipse sind u: a.Luna, Mars und Neon.

2. Laden Sie Toolkit for Eclipse herunter und installieren Sie es. Weitere Informationen hierzu finden Sieunter Handbuch „Erste Schritte” für AWS Toolkit for Eclipse.

3. Wählen Sie in Eclipse Help (Hilfe) und dann Install New Software (Neue Software installieren).4. Wählen Sie unter Available Software (Verfügbare Software) die Option Add (Hinzufügen).5. Wählen Sie unter Add Repository (Repository hinzufügen) die Option Archive (Archiv), navigieren Sie

zum Speicherort der .zip-Datei und öffnen Sie diese. Lassen Sie Name leer, und klicken Sie dann aufOK.

6. Wählen Sie unter Available Software (Verfügbare Software) die Option Select all (Alle auswählen), umAWS Core Management Tools (AWS-Kernverwaltungstools) und Developer Tools (Entwicklertools)auszuwählen. Wählen Sie dann Next (Weiter).

7. Wählen Sie unter Install Details (Details installieren) die Option Next (Weiter).8. Prüfen Sie unter Review Licenses (Lizenzen überprüfen) die Lizenzvereinbarungen. Wählen Sie I

accept the terms of the license agreement (Ich akzeptiere die Bedingungen der Lizenzvereinbarung.)und Finish (Beenden). Starten Sie Eclipse erneut.

Schritt 2: Importieren Ihres AWS CodeStar-Projekts in EclipseNachdem Sie Toolkit for Eclipse installiert haben, können Sie AWS CodeStar-Projekte importieren undbearbeiten sowie Code von der IDE bearbeiten, bestätigen und weitergeben.

Note

Sie können mehrere AWS CodeStar-Projekte zu einem einzigen Arbeitsbereich in Eclipsehinzufügen, dann müssen Sie jedoch Ihre Projekt-Anmeldeinformationen aktualisieren, wenn Sievon einem Projekt zu einem anderen wechseln.

So importieren Sie ein AWS CodeStar-Projekt:

1. Wählen Sie im AWS-Menü die Option Import AWS CodeStar Project (AWS CodeStar-ProjektImportieren) aus. Oder wählen Sie File (Datei) und dann Import (Importieren). Erweitern Sie unterSelect (Auswählen) AWS, und wählen Sie dann AWS CodeStar Project (AWS CodeStar-Projekt).

Wählen Sie Next.2. Wählen Sie unter AWS CodeStar Project Selection (Projektauswahl) Ihr AWS-Profil und die AWS-

Region, in der das AWS CodeStar-Projekt gehostet ist. Wenn Sie nicht bereits ein AWS-Profil miteinem Zugriffsschlüssels und einem geheimen Schlüssels auf Ihrem Computer konfiguriert haben,wählen Sie Configure AWS accounts (AWS-Konten konfigurieren), und befolgen Sie die Anweisungen.

Wählen Sie unter Select AWS CodeStar project and repository (Projekt und Repository auswählen) IhrAWS CodeStar-Projekt aus der Liste aus. Geben Sie unter Configure Git credentials (Konfigurieren derGit-Anmeldeinformationen) den Benutzernamen und das Passwort an, die Sie für den Zugriff auf dasRepository des Projekts erstellt haben. (Wenn Sie über keine Git-Anmeldeinformationen verfügen, vgl.Erste Schritte (p. 12).) Wählen Sie Next.

63

https://docs.aws.amazon.com/AWSToolkitEclipse/latest/GettingStartedGuide/setup-install.html


3. Alle Zweige des Repositorys des Projekts werden standardmäßig ausgewählt. Wenn Sie einen odermehrere Zweige nicht importieren möchten, löschen Sie die Fehler, und wählen Sie Next (Weiter).

4. Wählen Sie unter Local Destination (Lokales Ziel) eine Zieladresse, unter der der Importassistent daslokale Repository auf Ihrem Computer erstellen soll, und wählen Sie dann Finish (Fertigstellen).

5. Erweitern Sie unter Project Explorer den Projektbaum, um zu den Dateien im AWS CodeStar-Projektzu navigieren.

64


Schritt 3: Bearbeiten des AWS CodeStar-Project-Codes inEclipseNachdem Sie ein AWS CodeStar-Projekt in einen Eclipse-Arbeitsbereich importiert haben, können Sie denCode für das Projekt bearbeiten, speichern und bestätigen und ihn dann an das Quell-Repository für dasProjekt übergeben. Dies ist das gleiche Verfahren wie für jedes Git-Repository mit dem EGit-Plug-in fürEclipse. Weitere Informationen finden Sie unter EGit User Guide auf der Eclipse-Website.

So bearbeiten Sie Projekt-Code und führen Ihr erstes Commit zum Quell-Repository für ein AWSCodeStar-Projekt durch:

1. Erweitern Sie unter Project Explorer den Projektbaum, um zu den Dateien im AWS CodeStar-Projektzu navigieren.

2. Bearbeiten Sie eine oder mehrere Code-Dateien, und speichern Sie Ihre Änderungen.3. Wenn Sie bereit sind, um die Änderungen zu bestätigen, öffnen Sie das Kontextmenü für die Datei,

wählen Sie Team, und wählen Sie dann Commit (Durchführen).

Sie können diesen Schritt überspringen, wenn das Git-Staging-Fenster in Ihrer Projektansicht bereitsgeöffnet ist.

4. Stellen Sie unter Git Staging (Git-Bereitstellung) Ihre Änderungen bereit, indem Sie die geändertenDateien in Staged Changes (Bereitgestellte Änderungen) verschieben. Geben Sie eineBestätigungsmeldung in Commit Message (Commit-Meldung) ein, und wählen Sie dann Commit andPush.

65

https://wiki.eclipse.org/EGit/User_Guide

AWS CodeStar BenutzerhandbuchVisual Studio und AWS CodeStar

Um die Bereitstellung Ihrer Codeänderungen anzuzeigen, kehren Sie zum Dashboard für Ihr Projektzurück. Weitere Informationen finden Sie unter Schritt 3: Anzeigen Ihres Projekts (p. 9).

Visual Studio und AWS CodeStarSie können Visual Studio verwenden, um Code-Änderungen vorzunehmen und Software in einem AWSCodeStar-Projekt zu entwickeln.

Note

Die Informationen in diesem Thema gelten nur für AWS CodeStar-Projekte, die ihren Quellcode inCodeCommit speichern. Wenn Ihr AWS CodeStar-Projekt seinen Quellcode in GitHub speichert,können Sie ein Tool wie die GitHub Extension für Visual Studio einsetzen. Weitere Informationenfinden Sie auf der Seite Overview der Website für die GitHub Extension für Visual Studio und aufder GitHub-Website unter Getting Started with GitHub for Visual Studio.

Um Visual Studio zur Bearbeitung von Code im Quell-Repository für ein AWS CodeStar-Projekt zuverwenden, müssen Sie eine Version von AWS Toolkit for Visual Studio installieren, die die Integrationmit AWS CodeStar unterstützt. Sie müssen ein Mitglied des AWS CodeStar-Projektteams mit der RolleEigentümer oder Beitragender sein.

Für die Verwendung von Visual Studio brauchen Sie außerdem:

• Einen IAM-Benutzer, der einem AWS CodeStar-Projekt als Teammitglied hinzugefügt wurde.• AWS-Anmeldeinformationen für IAM-Benutzer (z. B. Ihr Zugriffsschlüssel und Ihr geheimer Schlüssel).• Ausreichende Berechtigungen für die Installation von Visual Studio und AWS Toolkit for Visual Studio auf

Ihrem lokalen Computer.

Toolkit for Visual Studio ist ein Softwarepaket, das Sie Visual Studio hinzufügen können. Es wird genau soinstalliert und verwaltet wie andere Softwarepakete in Visual Studio.

So installieren Sie Toolkit for Visual Studio mit dem AWS CodeStar-Modul und konfigurieren denZugriff auf Ihr Projekt-Repository

1. Installieren Sie Visual Studio auf Ihrem lokalen Computer.2. Laden Sie Toolkit for Visual Studio herunter, und installieren Sie es; speichern Sie die .zip-Datei in

einem lokalen Ordner oder Verzeichnis. Geben Sie auf der Seite Getting Started with the AWS Toolkitfor Visual Studio (Erste Schritte mit AWS Toolkit for Visual Studio) Ihre AWS-Anmeldeinformationenein oder importieren Sie sie, und wählen Sie dann Save and Close (Speichern und schließen).

3. Öffnen Sie in Visual Studio den Team Explorer. Suchen Sie unter Hosted Service ProvidersCodeCommit , und wählen Sie Connect (Verbinden).

4. Wählen Sie unter Manage Connections die Option Clone. Wählen Sie das Repository Ihres Projektsund den Ordner auf Ihrem lokalen Computer, wohin Sie das Repository klonen möchten, und wählenSie dann OK.

5. Wenn Sie dazu aufgefordert werden, Git-Anmeldeinformationen zu erstellen, wählen Sie Yes.Das Toolkit versucht, die Anmeldeinformationen für Sie zu erstellen. Speichern Sie die Datei mitden Anmeldeinformationen an einem sicheren Ort. Dies ist die einzige Möglichkeit, um dieseAnmeldeinformationen zu speichern. Wenn das Toolkit die Anmeldeinformationen für Sie nichterstellen kann, oder wenn Sie No auswählen, müssen Sie Ihre eigenen Git-Anmeldeinformationenerstellen und bereitstellen. Weitere Informationen finden Sie unter So richten Sie Ihren Computer soein, dass er Commits für Änderungen durchführt (IAM-Benutzer) (p. 12), oder folgen Sie den Online-Anweisungen.

Wenn Sie das Klonen des Projekts abgeschlossen haben, können Sie mit dem Bearbeiten Ihres Codesin Visual Studio beginnen und Ihre Änderungen bestätigen und an das Repository Ihres Projekts inCodeCommit übergeben.

66

https://visualstudio.github.com/index.html

https://github.com/github/VisualStudio/blob/master/docs/getting-started/index.md

AWS CodeStar BenutzerhandbuchAnpassen eines Projekt-Dashboards

Anpassen eines AWS CodeStar-DashboardsSie können Ihr Projekt-Dashboard durch Hinzufügen, Entfernen und Verschieben von Kacheln anpassen.Sie können auch die Team-Wiki-Kachel anpassen, um Informationen zu Ihrem Projekt anzuzeigen.

Themen• Hinzufügen, Entfernen oder Verschieben von Kacheln in Ihrem Dashboard (p. 67)• Hinzufügen einer Projekterweiterung zu Ihrem Dashboard (p. 67)• Anpassen der Team-Wiki-Kachel (p. 68)

Hinzufügen, Entfernen oder Verschieben von Kachelnin Ihrem DashboardSie können das Erscheinungsbild Ihres Projekt-Dashboards anpassen, indem Sie Kacheln hinzufügenentfernen oder deren Position und Anordnung im Dashboard verändern.

So ändern Sie das Erscheinungsbild Ihres Projekt-Dashboards:

• Um eine Kachel hinzuzufügen. wählen Sie Add tile (Kachel hinzufügen) und dann die Kachel aus derListe. Sie können jeweils nur eine Kachel jedes Typs hinzufügen.

• Um eine Kachel zu entfernen, wählen Sie im Projekt-Dashboard das Ellipsenmenü (…) auf dieser Kachelund anschließend Remove from Dashboard (Vom Dashboard entfernen).

• Um die Position einer Kachel im Dashboard zu ändern, ziehen Sie sie in die Position, an der sieerscheinen soll.

Hinzufügen einer Projekterweiterung zu IhremDashboardAWS CodeStar enthält Erweiterungen, die Ihrem Dashboard Kacheln und Funktionen hinzufügen. Siekönnen beispielsweise die JIRA-Erweiterung konfigurieren, so dass eine JIRA-Kachel Ihrem Projekt-Dashboard hinzugefügt und konfiguriert wird.

Um eine Projekterweiterung zu Ihrem Dashboard hinzuzufügen, wählen Sie auf der Navigationsleiste für IhrProjekt Extensions (Erweiterungen). Neben der Erweiterung, die Sie hinzufügen möchten, wählen Sie Showauf Dashboard (Am Dashboard anzeigen).

Um eine Erweiterung einzurichten, die auf Ihrem Dashboard angezeigt wird, wählen Sie die Schaltflächeoder den Befehl "connect" auf der Erweiterung und folgen Sie dann den Anweisungen, um die Einrichtungabzuschließen.

So entfernen Sie eine Erweiterung, die auf Ihrem Dashboard angezeigt wird:

• Wählen Sie das Ellipsenmenü (…) auf der Kachel, die Sie entfernen möchten, und anschließend Removefrom Dashboard (Vom Dashboard entfernen).

• Wählen Sie auf der Navigationsleiste für Ihr Projekt Extensions (Erweiterungen). Neben der Erweiterung,die Sie entfernen möchten, wählen Sie Hide from Dashboard (Am Dashboard ausblenden).

67

AWS CodeStar BenutzerhandbuchAnpassen der Team-Wiki-Kachel

Anpassen der Team-Wiki-KachelJedes AWS CodeStar-Projekt enthält eine anpassbare Team-Wiki-Kachel. Sie können den Namen dieserKachel und ihre Inhalte ändern. Mit dieser anpassbaren Kachel können Sie Links an Teamressourcenübergeben oder Codebeispiele hervorheben. Alle Projekt-Teammitglieder sehen diese Kachel, ihre Inhaltekönnen jedoch nur von Teammitgliedern geändert werden, denen die Rolle Beitragender oder Eigentümerzugewiesen wurde. Diese Kachel unterstützt sowohl Klartext, als auch CommonMark-Inhalt, mit denfolgenden Unterschieden:

• Sie können die Syntax in der Programmiersprache Codeblöcke hervorheben. Geben Sie dazu dieSprache an, gefolgt von dem Code. Zum Beispiel für JavaScript:

```JavaScriptvar hello = function() { console.log("hello world");}```

• Die Inline-Einbettung von Bildern wird nicht unterstützt.

Note

Verwenden Sie diese Kachel nicht zum Speichern vertraulicher Daten.

So passen Sie die Team-Wiki-Kachel in einem Projekt an:


Wählen Sie das Projekt.2. Wählen Sie im Projekt-Dashboard die Ellipsenschaltfläche (…) für die Projektinformationskachel und

dann Edit (Bearbeiten).3. Geben Sie im Markdown Editor den neuen Namen der Kachel unter Title (Titel) ein. Fügen Sie unter

Markdown content Klartext oder CommonMark-Inhalte ein. Sie können beispielsweise einen Link zuIhrem Team-Projekt oder andere Inhalte einfügen.

Wählen Sie Save aus.

Ein Schritt-für-Schritt-Beispiel finden Sie unter Schritt 4: Anpassen der Kachel „Team Wiki” und des Projekt-Dashboards (p. 10).

Ändern von AWS-Ressourcen in einem AWSCodeStar-Projekt

Nach dem Erstellen eines Projekts in AWS CodeStar können Sie den Standardsatz der AWS-Ressourcenändern, die AWS CodeStar dem Projekt hinzufügt.

Unterstützte RessourcenänderungenDie folgende Tabelle listet die unterstützten Änderungen an den AWS-Standardressourcen in einem AWSCodeStar-Projekt auf.

68

http://commonmark.org/help/


http://commonmark.org/help/

AWS CodeStar BenutzerhandbuchUnterstützte Ressourcenänderungen

Änderung Hinweise

Hinzufügen einer Stufe zu AWS CodePipeline. Siehe Hinzufügen einer Stufe zu AWSCodePipeline (p. 70).

Ändern der Elastic Beanstalk-Umgebungseinstellungen.

Siehe Ändern der AWS Elastic Beanstalk-Umgebungseinstellungen (p. 70).

Ändern des Codes oder der Einstellungen einerAWS Lambda-Funktion, der zugehörigen IAM-Rolleoder der zugehörigen API in Amazon API Gateway.

Siehe Ändern einer AWS Lambda-Funktion inQuellcode (p. 70).

Hinzufügen einer Ressource zu einem AWSLambda-Projekt und Erweitern der Berechtigungenzum Erstellen und zum Zugriff auf die neueRessource.

Siehe Hinzufügen einer Ressource zu einemProjekt (p. 73).

Hinzufügen von Traffic-Verschiebungen mitCodeDeploy für eine AWS Lambda-Funktion.

Siehe Shift Traffic für ein AWS Lambda-Projekt (p. 85).

Hinzufügen von AWS X-Ray-Unterstützung Siehe Tracing für ein Projekt aktivieren (p. 71).

Bearbeiten Sie die Datei buildspec.yml fürIhr Projekt, um eine Unit-Test-Buildphase zurAusführung durch AWS CodeBuild hinzuzufügen.

Siehe Schritt 7: Hinzufügen eines Einheitentests fürden Webservice (p. 28) im Tutorial für serverloseProjekte.

Fügen Sie Ihrem Projekt Ihre eigene IAM-Rollehinzu.

Siehe Hinzufügen einer IAM-Rolle zu einemProjekt (p. 77).

Ändern einer IAM-Rollendefinition. Für Rollen, die im Anwendungs-Stack definiertsind. Sie können keine Rollen ändern, die in derToolchain oder AWS CloudFormation-Stacksdefiniert sind.

Ändern Sie Ihr Lambda-Projekt, um einenEndpunkt hinzuzufügen.

Ändern Sie Ihr EC2-Projekt, um einen Endpunkthinzuzufügen.

Ändern Sie Ihr Elastic Beanstalk-Projekt, um einenEndpunkt hinzuzufügen.

Bearbeiten Sie Ihr Projekt, um eine Prod-Stufe undeinen Endpunkt hinzuzufügen.

Siehe Fügen Sie eine Prod-Stufe und einenEndpunkt zu einem Projekt hinzu. (p. 78).

Verwenden Sie sicher SSM-Parameter in einemAWS CodeStar-Projekt.

Siehe the section called “Sicheres Verwendenvon SSM-Parametern in einem AWS CodeStar-Projekt” (p. 84).

Die folgenden Änderungen werden nicht unterstützt.

• Wechseln zu einem anderen Deployment-Ziel (z. B. Bereitstellung auf AWS Elastic Beanstalk anstellevon AWS CodeDeploy)

• Hinzufügen eines verständlichen Web-Endpunkt-Namens.• Ändern des CodeCommit-Repository-Namen (für ein AWS CodeStar-Projekt, das mit CodeCommit

verbunden ist)

69

AWS CodeStar BenutzerhandbuchHinzufügen einer Stufe zu AWS CodePipeline

• Trennen des GitHub-Repository (für ein mit GitHub verbundenes AWS CodeStar-Projekt) und erneutesVerbinden des Repository mit diesem Projekt, oder Verbinden eines anderen Repository mit diesemProjekt. Sie können die CodePipeline-Konsole (nicht die AWS CodeStar-Konsole) verwenden, umdie Trennung und erneute Verbindung mit GitHub in der Source-Phase einer Pipeline durchzuführen.Wenn Sie jedoch die Source-Phase mit einem anderen GitHub-Repository neu verbinden, sindauf dem AWS CodeStar-Dashboard für das Projekt die Informationen auf den Kacheln Applicationendpoints (Anwendungsendpunkte), Commit history (Commit-Verlauf) und GitHub Issues (GitHub-Probleme) möglicherweise falsch oder veraltet. Durch das Trennen des GitHub-Repositorys werden dieInformationen dieses Repositorys nicht aus dem Commit-Verlauf gelöscht, und GitHub gibt Kacheln aufdem AWS CodeStar-Dashboard für das Projekt aus. Um diese Informationen zu entfernen, verwendenSie die GitHub-Website, um den Zugriff auf GitHub von dem AWS CodeStar-Projekt aus zu deaktivieren.Um den Zugriff zu widerrufen, verwenden Sie auf der GitHub-Website den Abschnitt Authorized OAuthApps (Autorisierte OAuth-Apps) auf der Einstellungsseite Ihres GitHub-Kontoprofils.

• Trennen des CodeCommit-Repositorys (für ein AWS CodeStar-Projekt, das mit CodeCommit verbundenist) und erneutes Verbinden des Repository mit diesem Projekt, oder Verbinden eines anderenRepositorys mit diesem Projekt.

Hinzufügen einer Stufe zu AWS CodePipelineSie können einer Pipeline, die, AWS CodeStar in einem Projekt erstellt, eine neue Stufe hinzufügen.Weitere Informationen finden Sie unter Bearbeiten einer Pipeline in AWS CodePipeline im AWSCodePipeline-Benutzerhandbuch.

Note

Wenn die neue Stufe von AWS-Ressourcen abhängt, die AWS CodeStar nicht erstellt hat, könntedie Pipeline unterbrochen werden. Der Grund dafür ist, dass die IAM-Rolle, die AWS CodeStarfür AWS CodePipeline erstellt hat, möglicherweise nicht standardmäßig auf diese Ressourcenzugreifen kann.Um zu versuchen, AWS CodePipeline den Zugriff auf AWS-Ressourcen zu gewähren, die nichtvon AWS CodeStar erstellt wurden, sollten Sie eventuell die von AWS CodeStar erstellte IAM-Rolle ändern. Dies wird nicht unterstützt, da AWS CodeStar Ihre IAM-Rollenänderungen entfernenkann, wenn es regelmäßige Aktualisierungsprüfungen des Projekts durchführt.

Ändern der AWS Elastic Beanstalk-UmgebungseinstellungenSie können die Einstellungen einer Elastic Beanstalk-Umgebung ändern, die AWS CodeStar ineinem Projekt erstellt. Sie möchten beispielsweise die Elastic Beanstalk-Standardumgebung in IhremAWS CodeStar-Projekt von „Einzelne Instance“ in „Load Balanced“ ändern. Bearbeiten Sie dazu dietemplate.yml-Datei im Projekt-Repository. Möglicherweise müssen Sie auch die Berechtigungen fürdie Rollen der Mitarbeiter Ihres Projekts ändern. Nachdem Sie die Vorlage geändert haben, stellen AWSCodeStar und AWS CloudFormation die Ressourcen für Sie bereit.

Weitere Informationen zum Bearbeiten der template.yml-Datei finden Sie unter Ändern vonAnwendungsressourcen mit der Datei Template.yml (p. 44). Weitere Informationen zu ElasticBeanstalk-Umgebungen finden Sie unter AWS Elastic Beanstalk Environment Management Console imEntwicklerhandbuch für AWS Elastic Beanstalk.

Ändern einer AWS Lambda-Funktion in QuellcodeSie können den Code oder Einstellungen einer Lambda-Funktion oder die zugehörige IAM-Rolle oderdie API Gateway-API, die AWS CodeStar in einem Projekt erstellt, ändern. Zu diesem Zweck empfehlen

70

https://docs.aws.amazon.com/codepipeline/latest/userguide/pipelines-edit.html

https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-console.html

AWS CodeStar BenutzerhandbuchTracing für ein Projekt aktivieren

wir die Verwendung des AWS Serverless Application Model (AWS-SAM) zusammen mit der Dateitemplate.yaml im CodeCommit-Repository Ihres Projekts. Diese template.yaml-Datei definiertName, Handler und Laufzeit Ihrer Funktion, die zugehörige IAM-Rolle sowie die zugehörige API in APIGateway. Weitere Informationen finden Sie unter Erstellen serverloser Anwendungen mit AWS-SAM aufder GitHub-Website.

Tracing für ein Projekt aktivierenAWS X-Ray bietet Tracing, mit dem Sie das Performance-Verhalten von verteilten Anwendungen (z.B.Latenzen bei den Reaktionszeiten) analysieren können. Nachdem Sie Traces zu Ihrem AWS CodeStar-Projekt hinzugefügt haben, können Sie die AWS X-Ray-Konsole verwenden, um Anwendungsansichtenund Reaktionszeiten anzuzeigen.

Note

Sie können diese Schritte für die folgenden Projekte verwenden, die mit den folgendenÄnderungen der Projektunterstützung erstellt wurden:

• Alle Lambda-Projekte.• Für Amazon EC2- oder Elastic Beanstalk-Projekte, die nach dem 3. August 2018 erstellt

wurden, stellte AWS CodeStar eine /template.yml-Datei im Projekt-Repository bereit.

Jede AWS CodeStar-Vorlage enthält eine AWS CloudFormation-Datei, die die AWS-Laufzeitabhängigkeiten Ihrer Anwendung, wie Datenbanktabellen und Lambda-Funktionen, modelliert.Diese Datei ist in Ihrem Quell-Repository in der Datei /template.yml gespeichert.

Sie können diese Datei ändern, um Tracing hinzuzufügen, indem Sie die AWS X-Ray-Ressource zumAbschnitt Resources hinzufügen. Anschließend ändern Sie die IAM-Berechtigungen für Ihr Projekt,damit AWS CloudFormation die Ressource erstellen kann. Informationen zu Vorlagenelementen undFormatierung finden Sie unter AWS Ressourcentypen Referenz.

Dies sind die übergeordneten Schritte, die Sie befolgen müssen, um Ihre Vorlage anzupassen.

1. Schritt 1: Bearbeiten der Auftragnehmer-Rolle in IAM für die Nachverfolgung (p. 71)2. Schritt 2: Ändern der Datei template.yml für das Tracing. (p. 72)3. Schritt 3: Commit und Push Ihrer Vorlagenänderung für das Tracing (p. 72)4. Schritt 4: Überwachen des AWS CloudFormation Stack Update für das Tracing (p. 72)

Schritt 1: Bearbeiten der Auftragnehmer-Rolle in IAM für dieNachverfolgungSie müssen als Administrator angemeldet sein, um die Schritte 1 und 4 ausführen zu können. Dieser Schrittzeigt ein Beispiel für die Bearbeitung von Berechtigungen für ein Lambda-Projekt.

Note

Sie können diesen Schritt überspringen, wenn Ihr Projekt mit einer Berechtigungsgrenzebereitgestellt wurde.Für Projekte, die nach 6. Dezember 2018 PDT erstellt wurden, hat AWS CodeStar Ihr Projekt miteiner Berechtigungsgrenzen-Richtlinie bereitgestellt.


71

https://github.com/awslabs/serverless-application-model/blob/master/HOWTO.md



AWS CodeStar BenutzerhandbuchTracing für ein Projekt aktivieren

2. Erstellen Sie ein Projekt oder wählen Sie ein bestehendes Projekt mit einer template.yml file-Datei und öffnen Sie dann die Seite Project resources (Projektressourcen).

3. Suchen Sie unter Project Resources (Projektressourcen) die für die CodeStarWorker/Lambda-Rolleerstellte IAM-Rolle in der Ressourcenliste. Der Rollenname folgt dem folgenden Format role/CodeStarWorker-Project_name-lambda-Function_name. Wählen Sie den ARN für die Rolle.

4. Die Rolle öffnet sich in der IAM-Konsole. Wählen Sie Attach Policies (Richtlinien hinzufügen). SuchenSie nach der AWSXrayWriteOnlyAccess-Richtlinie, markieren Sie das Kästchen daneben undwählen Sie dann Attach Policy (Richtlinie anfügen).

Schritt 2: Ändern der Datei template.yml für das Tracing.1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar.2. Wählen Sie Ihr serverloses Projekt und öffnen Sie dann die Seite Code. Suchen und bearbeiten Sie

in der obersten Ebene Ihres Repositorys die Datei template.yml. Fügen Sie unter Resources dieRessource in den Abschnitt Properties ein.

Tracing: Active

Dieses Beispiel zeigt eine modifizierte Vorlage:

Schritt 3: Commit und Push Ihrer Vorlagenänderung für dasTracing• Übertragen und verschieben Sie die Änderungen in der Datei template.yml.

Note

Dadurch wird Ihre Pipeline gestartet. Wenn Sie die Änderungen übertragen, bevor Sie dieIAM-Berechtigungen aktualisieren, startet Ihre Pipeline, das AWS CloudFormation-Stack-Update stößt auf Fehler, und das Stack-Update wird zurückgesetzt. In diesem Fall korrigierenSie die Berechtigungen und starten Sie die Pipeline neu.

Schritt 4: Überwachen des AWS CloudFormation Stack Updatefür das Tracing1. Das Update des AWS CloudFormation-Stacks startet, wenn die Pipeline für Ihr Projekt mit der

Bereitstellungsstufe beginnt. Um den Status des Stack-Updates anzuzeigen, wählen Sie in Ihrem AWSCodeStar Dashboard die AWS CloudFormation-Stufe in Ihrer Pipeline.

72


AWS CodeStar BenutzerhandbuchHinzufügen einer Ressource zu einem Projekt

Wenn das Stack-Update in AWS CloudFormation Fehler zurückgibt, lesen Sie die Hinweisezur Fehlerbehebung in AWS CloudFormation: Stapelbildung wegen fehlender Berechtigungenzurückgerollt (p. 153). Wenn in der Rolle des Auftragnehmers Berechtigungen fehlen, bearbeitenSie die Richtlinie, die der Lambda-Auftragnehmerrolle Ihres Projekts zugeordnet ist. Siehe Schritt 1:Bearbeiten der Auftragnehmer-Rolle in IAM für die Nachverfolgung (p. 71).

2. Verwenden Sie das Dashboard, um die erfolgreichen Ausführung Ihrer Pipeline anzuzeigen. DasTracing ist nun in Ihrer Anwendung aktiviert.

3. Stellen Sie sicher, dass das Tracing aktiviert ist, indem Sie die Details zu Ihrer Funktion in der Lambda-Konsole anzeigen.

4. Wählen Sie den Anwendungsendpunkt für Ihr Projekt. Diese Interaktion mit Ihrer Anwendung wirdverfolgt. Sie können die Ablaufverfolgungsinformationen in der AWS X-Ray-Konsole anzeigen.

Hinzufügen einer Ressource zu einem ProjektJede AWS CodeStar-Vorlage für alle Projekte enthält eine AWS CloudFormation-Datei, die die AWS-Laufzeitabhängigkeiten Ihrer Anwendung, wie Datenbanktabellen und Lambda-Funktionen, modelliert. Sieist in Ihrem Quell-Repository in der Datei /template.yml gespeichert.

Note

Sie können diese Schritte für die folgenden Projekte verwenden, die mit den folgendenÄnderungen der Projektunterstützung erstellt wurden:

• Alle Lambda-Projekte.• Für Amazon EC2- oder Elastic Beanstalk-Projekte, die nach dem 3. August 2018 erstellt

wurden, stellte AWS CodeStar eine /template.yml-Datei im Projekt-Repository bereit.

Sie können diese Datei ändern, indem Sie AWS CloudFormation-Ressourcen zum AbschnittResources hinzufügen. Durch das Ändern der Datei template.yml können AWS CodeStar undAWS CloudFormation die neue Ressource zu Ihrem Projekt hinzufügen. Einige Ressourcen erfordern,dass Sie der Richtlinie für die Rolle des CloudFormation Auftragnehmers Ihres Projekts weitereBerechtigungen hinzufügen. Informationen zu Vorlagenelementen und Formatierung finden Sie unter AWSRessourcentypen Referenz.

Nachdem Sie festgelegt haben, welche Ressourcen Sie zu Ihrem Projekt hinzufügen müssen, sind diesdie übergeordneten Schritte, die Sie ausführen müssen, um eine Vorlage anzupassen. Informationenzu AWS CloudFormation-Ressourcen und ihre erforderlichen Eigenschaften finden Sie unter AWSRessourcentypen-Referenz.

1. Schritt 1: Bearbeiten der CloudFormation-Auftragnehmer-Rolle im IAM (p. 74) (falls erforderlich)2. Schritt 2: Bearbeiten der Datei template.yml (p. 74)3. Schritt 3: Commit und Push Ihrer Vorlagenänderung (p. 75)4. Schritt 4: Überwachen Sie das AWS CloudFormation Stack-Update (p. 75)5. Schritt 5: Hinzufügen von Ressourcenberechtigungen mit einer Inline-Richtlinie (p. 76)

73






Verwenden Sie die Schritte in diesem Abschnitt, um Ihre AWS CodeStar-Projektvorlage zu ändern, umeine Ressource hinzuzufügen und dann die Berechtigungen der CloudFormation Auftragnehmer-Rolledes Projekts in IAM zu erweitern. In diesem Beispiel wird die Ressource AWS::SQS::Queue der Dateitemplate.yml hinzugefügt. Die Änderung startet eine automatisierte Antwort in AWS CloudFormation,die Ihrem Projekt eine Amazon Simple Queue Service-Warteschlange hinzufügt.

Schritt 1: Bearbeiten der CloudFormation-Auftragnehmer-Rolle imIAMSie müssen als Administrator angemeldet sein, um die Schritte 1 und 5 ausführen zu können.

Note

Sie können diesen Schritt überspringen, wenn Ihr Projekt mit einer Berechtigungsgrenzebereitgestellt wurde.Für Projekte, die nach 6. Dezember 2018 PDT erstellt wurden, hat AWS CodeStar Ihr Projekt miteiner Berechtigungsgrenzen-Richtlinie bereitgestellt.


2. Erstellen Sie ein Projekt oder wählen Sie ein bestehendes Projekt mit einer template.yml file-Datei und öffnen Sie dann die Seite Project resources (Projektressourcen).

3. Suchen Sie unter Project Resources (Projektressourcen) die für die CodeStarWorker/AWSCloudFormation-Rolle erstellte IAM-Rolle in der Ressourcenliste. Der Rollenname folgt dem folgendenFormat role/CodeStarWorker-Project_name-CloudFormation.

4. Die Rolle öffnet sich in der IAM-Konsole. Erweitern Sie auf der Registerkarte Permissions(Berechtigungen) im Bereich Inline Policies (Eingebundene Richtlinien) die Zeile für Ihre Servicerollen-Richtlinie und wählen Sie die Option Edit Policy (Richtlinie bearbeiten) aus.

5. Wählen Sie die Registerkarte JSON, um die Richtlinie zu bearbeiten.

Note

Die Richtlinie, die der Auftragnehmer-Rolle zugeordnet ist, istCodeStarWorkerCloudFormationRolePolicy.

6. Fügen Sie im Feld JSON die folgende Richtlinienanweisung in das Element Statement ein.

{ "Action": [ "sqs:CreateQueue", "sqs:DeleteQueue", "sqs:GetQueueAttributes", "sqs:SetQueueAttributes", "sqs:ListQueues", "sqs:GetQueueUrl" ], "Resource": [ "*" ], "Effect": "Allow"}

7. Wählen Sie Review policy (Richtlinie überprüfen), um zu überprüfen, dass die Richtlinie fehlerfrei ist,und wählen Sie dann Save changes (Änderungen speichern).

Schritt 2: Bearbeiten der Datei template.yml1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar.

74

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sqs-queues.html




2. Wählen Sie Ihr serverloses Projekt und öffnen Sie dann die Seite Code. Notieren Sie sich in derobersten Ebene Ihres Repository den Speicherort von template.yml.

3. Verwenden Sie eine IDE, die Konsole oder die Befehlszeile in Ihrem lokalen Repository, um dieDatei template.yml in Ihrem Repository zu bearbeiten. Fügen Sie die Ressource in den AbschnittResources ein. In diesem Beispiel wird sie beim Kopieren des folgenden Textes in den AbschnittResources hinzugefügt.

Resources: TestQueue: Type: AWS::SQS::Queue

Dieses Beispiel zeigt eine modifizierte Vorlage:

Schritt 3: Commit und Push Ihrer Vorlagenänderung• Übertragen und verschieben Sie die Änderungen in der Datei template.yml, die Sie in Schritt 2

gespeichert haben.

Note

Dadurch wird Ihre Pipeline gestartet. Wenn Sie die Änderungen übertragen, bevor Sie dieIAM-Berechtigungen aktualisieren, startet Ihre Pipeline und das AWS CloudFormation-Stack-Update stößt auf Fehler, wodurch das Stack-Update zurückgesetzt wird. In diesem Fallkorrigieren Sie die Berechtigungen und starten Sie die Pipeline neu.

Schritt 4: Überwachen Sie das AWS CloudFormation Stack-Update1. Wenn die Pipeline für Ihr Projekt mit der Bereitstellungsstufe beginnt, wird das Update des AWS

CloudFormation-Stacks gestartet. Sie können die Phase der AWS CloudFormation in Ihrer Pipeline aufIhrem AWS CodeStar Dashboard auswählen, um das Stack-Update zu sehen.

Fehlerbehebung

Das Stack-Update schlägt fehl, wenn die erforderlichen Ressourcenberechtigungen fehlen. Zeigen Sieden Fehlerstatus in der AWS CodeStar Dashboard-Ansicht der Pipeline für Ihr Projekt an.

75


Wählen Sie den Link CloudFormation in der Bereitstellungsstufe Ihrer Pipeline, um den Fehlerin der AWS CloudFormation-Konsole zu suchen. Wählen Sie in der Konsole in der Liste Events(Ereignisse),Ihr Projekt aus, um die Details der Stapelerstellung anzuzeigen. Es wird eine Nachricht mitden Fehlerdetails angezeigt. In diesem Beispiel fehlt die sqs:CreateQueue-Berechtigung.

Fügen Sie fehlende Berechtigungen hinzu, indem Sie die Richtlinie bearbeiten, die an die AWSCloudFormation Auftragnehmer-Rolle Ihres Projekts angefügt ist. Siehe Schritt 1: Bearbeiten derCloudFormation-Auftragnehmer-Rolle im IAM (p. 74).

2. Nach einem erfolgreichen Durchlauf Ihrer Pipeline werden die Ressourcen in Ihrem AWSCloudFormation-Stack angelegt. Zeigen Sie in der Liste Resources (Ressourcen) in AWSCloudFormation die Ressource an, die für Ihr Projekt erstellt wurde. In diesem Beispiel ist dieWarteschlange TestQueue in den Resources (Ressourcen) aufgelistet.

Die Warteschlangen-URL ist in AWS CloudFormation verfügbar. Die Warteschlangen-URL weist dasfolgende Format auf:

https://{REGION_ENDPOINT}/queue.|api-domain|/{YOUR_ACCOUNT_NUMBER}/{YOUR_QUEUE_NAME}

Weitere Informationen finden Sie unter Senden einer Amazon SQS-Nachricht, Empfangen einerNachricht in einer Amazon SQS-Warteschlange und Löschen einer Nachricht in einer Amazon SQS-Warteschlange.

Schritt 5: Hinzufügen von Ressourcenberechtigungen mit einerInline-RichtlinieGewähren Sie Teammitgliedern Zugriff auf Ihre neue Ressource, indem Sie der Rolle des Benutzers dieentsprechende Inline-Richtlinie hinzufügen. Nicht alle Ressourcen erfordern, dass Sie Berechtigungenhinzufügen. Um die folgenden Schritte auszuführen, müssen Sie sich entweder als Root-Benutzer,IAM-Administratorbenutzer im Konto oder als IAM-Benutzer oder verbundener Benutzer mit derAdministratorAccess-Verwaltungsrichtlinie oder ähnlichem in der Konsole angemeldet haben.

1. Wählen Sie in der IAM-Konsole Users (Benutzer) und dann das Benutzerkonto aus.2. Wählen Sie in der Registerkarte Permissions (Berechtigungen) die Option Add inline policy (Inline-

Richtlinie hinzufügen). Wählen Sie auf der Seite Create policy (Richtlinie erstellen) die RegisterkarteJSON aus.

3. Fügen Sie in der Registerkarte JSON die Richtlinie für Ihre neue Ressource ein. Verwenden Siedie Berechtigungen, die für die gewünschte Zugriffsebene geeignet sind. Dieses Beispiel stellt dieSchreibgeschützt-Richtlinie für die Amazon SQS-Ressource dar. Kopieren und fügen Sie die hierbereitgestellte JSON-Richtlinie ein.

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [

76

https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/SendMessage.html#send-sqs-message

https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/ReceiveMessage.html#receive-sqs-message

https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/ReceiveMessage.html#receive-sqs-message

https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/DeleteMessage.html#delete-sqs-message

https://docs.aws.amazon.com/sdk-for-net/v2/developer-guide/DeleteMessage.html#delete-sqs-message

AWS CodeStar BenutzerhandbuchHinzufügen einer IAM-Rolle zu einem Projekt

"sqs:Get*", "sqs:List*", "sqs:Receive*" ], "Resource": "*" } ]}

4. Wählen Sie Review policy (Richtlinie überprüfen) aus, und klicken Sie dann auf Create policy(Richtlinie erstellen).

5. Geben Sie in das Feld Name einen Namen für Ihre Inline-Richtlinie ein. Um das Auffinden und ÄndernIhrer Richtlinie zu erleichtern, fügen Sie Ihren AWS CodeStar-Projektnamen in den Richtlinientitel ein.

6. Die aktualisierte Anweisung wird als direkt an den Benutzer angefügt angezeigt.7. Falls erforderlich, kopieren Sie die Richtlinie auf andere Teammitglieder.

Important

AWS CodeStar verwaltet keine Inline-Richtlinie, die für eine zusätzliche Ressource erstelltwurde. Um die Berechtigungen des Benutzers zu entfernen oder gelöschte Ressourcen zubereinigen, müssen Sie die Inline-Richtlinie manuell löschen.

Hinzufügen einer IAM-Rolle zu einem ProjektAb dem 6. Dezember 2018 PDT können Sie Ihre eigenen Rollen und Richtlinien im Anwendungs-Stack(template.yml) definieren. Um das Risiko von Berechtigungseskalationen und destruktiver Aktionen zuminimieren, müssen Sie die projektspezifische Berechtigungsgrenze für jede von Ihnen erstellte IAM-Entitätfestlegen. Wenn Sie ein Lambda-Projekt mit mehreren Funktionen haben, ist es eine bewährte Methode,für jede Funktion eine IAM-Rolle anzulegen.

So fügen Sie eine IAM-Rolle zu Ihrem Projekt hinzu

1. Bearbeiten Sie die Datei template.yml für Ihr Projekt.2. Fügen Sie im Abschnitt Resources: Ihre IAM-Ressource mithilfe des Formats im folgenden Beispiel

hinzu:

SampleRole: Description: Sample Lambda role Type: AWS::IAM::Role Properties: AssumeRolePolicyDocument: Statement: - Effect: Allow Principal: Service: [lambda.amazonaws.com] Action: sts:AssumeRole ManagedPolicyArns: - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole PermissionsBoundary: !Sub 'arn:${AWS::Partition}:iam::${AWS::AccountId}:policy/CodeStar_${ProjectId}_PermissionsBoundary'

3. Veröffentlichen Sie Ihre Änderungen über die Pipeline und überprüfen Sie den Erfolg.

77

AWS CodeStar BenutzerhandbuchFügen Sie eine Prod-Stufe und einen

Endpunkt zu einem Projekt hinzu.

Fügen Sie eine Prod-Stufe und einen Endpunkt zueinem Projekt hinzu.Verwenden Sie die Verfahren in diesem Abschnitt, um eine neue Produktions (Prod)-Stufe zu IhrerPipeline und eine manuelle Genehmigungsstufe zwischen der Bereitstellungs- und Prod-Stufe IhrerPipeline hinzuzufügen. Dadurch wird ein zusätzlicher Ressourcenstapel erstellt, wenn Ihre Projekt-Pipelineausgeführt wird.

Note

Sie können diese Verfahren verwenden, wenn:

• Für Projekte, die nach dem 3. August 2018 erstellt wurden, stellt AWS CodeStar für Ihr AmazonEC2-, Elastic Beanstalk- oder Lambda-Projekt eine /template.yml-Datei im Projekt-Repository bereit.

• Für Projekte, die nach 6. Dezember 2018 PDT erstellt wurden, hat AWS CodeStar Ihr Projektmit einer Berechtigungsgrenzen-Richtlinie bereitgestellt.

Alle AWS CodeStar-Projekte verwenden eine AWS CloudFormation-Vorlagendatei, die die AWS-Laufzeitabhängigkeiten Ihrer Anwendung, wie Linux-Instances und Lambda-Funktionen, modelliert. DieDatei /template.yml ist in Ihrem Quell-Repository gespeichert.

In der Datei /template.yml, verwenden Sie den Parameter Stage, um einen Ressourcenstapel für eineneue Stufe in der Projekt-Pipeline hinzuzufügen.

Stage: Type: String Description: The name for a project pipeline stage, such as Staging or Prod, for which resources are provisioned and deployed. Default: ''

Der Parameter Stage gilt für alle benannten Ressourcen, bei denen die Projekt-ID in der Ressourcereferenziert ist. Zum Beispiel ist der folgende Rollenname eine benannte Ressource in der Vorlage:

RoleName: !Sub 'CodeStar-${ProjectId}-WebApp${Stage}'

VoraussetzungenVerwenden Sie die Vorlagenoptionen in der AWS CodeStar-Konsole zum Erstellen eines Projekts.

Ihr IAM-Benutzer muss über die folgenden Berechtigungen verfügen:

• iam:PassRole für die AWS CloudFormation-Projektrolle.• iam:PassRole für die Projekt-Toolchain-Rolle.• cloudformation:DescribeStacks

• cloudformation:ListChangeSets

Nur für Amazon EC2- oder Elastic Beanstalk-Projekte:

• codedeploy:CreateApplication

• codedeploy:CreateDeploymentGroup

• codedeploy:GetApplication

78



• codedeploy:GetDeploymentConfig

• codedeploy:GetDeploymentGroup

• elasticloadbalancing:DescribeTargetGroups

Themen• Schritt 1: Erstellen einer Anwendung und einer Bereitstellungsgruppe in CodeDeploy (Nur Amazon

EC2-Projekte) (p. 79)• Schritt 2: Hinzufügen einer neuen Pipeline für die Prod-Stufe (p. 80)• Schritt 3: Hinzufügen einer manuellen Genehmigungsstufe (p. 83)• Schritt 4: Übertragen einer Änderung und Überwachen der AWS CloudFormation-Stack-

Aktualisierung (p. 83)

Schritt 1: Erstellen einer Anwendung und einerBereitstellungsgruppe in CodeDeploy (Nur Amazon EC2-Projekte)Wählen Sie Ihre CodeDeploy-Anwendung und fügen Sie dann eine neue Bereitstellungsgruppe hinzu, dieder neuen Instance zugeordnet ist.

Note

Wenn Ihr Projekt ein Lambda- oder Elastic Beanstalk-Projekt ist, können Sie diesen Schrittüberspringen.

1. Öffnen Sie die CodeDeploy-Konsole unter https://console.aws.amazon.com/codedeploy.2. Wählen Sie Create application aus.3. Geben Sie in Application name (Anwendungsname) einen Namen für Ihre Anwendung ein, der den

Projektnamen und die Prod-Stufe beinhaltet (z. B. <project-id>-prod).4. Wählen Sie unter Compute Platform (Plattform für die Datenverarbeitung) die Option EC2/On-premises

(EC2/Lokal) aus.5. Wählen Sie Create application aus.6. Wählen Sie unter Deployment groups Create deployment group aus.7. Geben Sie unter Deployment group name (Name der Bereitstellungsgruppe) <project-id>-prod-

Env ein.8. Wählen Sie unter Service role (Servicerolle) die Toolchain-Auftragnehmerrolle für Ihr AWS CodeStar-

Projekt.9. Wählen Sie unter Deployment type (Bereitstellungstyp) die Option In-place (Direkt).10. Wählen Sie unter Environment configuration (Umgebungskonfiguration) die Registerkarte Amazon EC2

Instances.11. Wählen Sie unter dem Tag-Gruppe unter Key (Schlüssel) die Option aws:cloudformation:stack-

name. Wählen Sie unter Value (Wert) die Option awscodestar-<projectid>-infrastructure-prod (der für die Aktion GenerateChangeSet zu erstellende Stack).

12. Wählen Sie unter Deployment settings (Bereitstellungseinstellungen) die OptionCodeDeployDefault.AllAtOnce aus.

13. Deaktivieren Sie Choose a load balancer (Einen Load Balancer auswählen).14. Klicken Sie auf Create deployment group (Bereitstellungsgruppe erstellen).

Sie haben jetzt die zweite Bereitstellungsgruppe erstellt.

79

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



Schritt 2: Hinzufügen einer neuen Pipeline für die Prod-StufeFügen Sie eine Stufe mit dem gleichen Satz von Bereitstellungsaktionen wie in der BereitstellungsstufeIhres Projekts hinzu. Zum Beispiel sollte die neue Prod-Stufe für ein Amazon EC2-Projekt die gleichenAktionen aufweisen wie die für das Projekt erstellte Bereitstellungsstufe.

So kopieren Sie Parameter und Felder aus der Bereitstellungsstufe

1. Öffnen Sie Ihr AWS CodeStar-Projekt-Dashboard und wählen Sie Pipeline Details (Pipeline-Details),um Ihre Pipeline in der CodePipeline-Konsole zu öffnen.

2. Wählen Sie Edit (Bearbeiten) aus.3. Wählen Sie in der Bereitstellungsstufe die Option Edit stage (Stufe bearbeiten).4. Klicken Sie auf das "Bearbeiten"-Symbol auf der Aktion GenerateChangeSet. Notieren Sie sich die

Werte in den folgenden Feldern. Diese Werte verwenden Sie, wenn Sie Ihre neue Aktion erstellen.

• Stack name• Change set name (Name des Änderungssatzes)• Vorlage• Vorlagenkonfiguration• Input artifacts (Eingabeartefakte)

5. Erweitern Sie Advanced (Erweitert) und kopieren Sie in Parameters (Parameter) die Parameter fürIhr Projekt. Fügen Sie diese Parameter in Ihre neue Aktion ein. Kopieren Sie zum Beispiel die hiergezeigten Parameter in das JSON-Format:

• Lambda-Projekte:

{ "ProjectId":"MyProject"}

• Amazon EC2-Projekte:

{

"ProjectId":"MyProject", "InstanceType":"t2.micro", "WebAppInstanceProfile":"awscodestar-MyProject-WebAppInstanceProfile-EXAMPLEY5VSFS", "ImageId":"ami-EXAMPLE1", "KeyPairName":"my-keypair", "SubnetId":"subnet-EXAMPLE", "VpcId":"vpc-EXAMPLE1"}

• Elastic Beanstalk-Projekte:

{ "ProjectId":"MyProject", "InstanceType":"t2.micro", "KeyPairName":"my-keypair", "SubnetId":"subnet-EXAMPLE", "VpcId":"vpc-EXAMPLE", "SolutionStackName":"64bit Amazon Linux 2018.03 v3.0.5 running Tomcat 8 Java 8", "EBTrustRole":"CodeStarWorker-myproject-EBService", "EBInstanceProfile":"awscodestar-myproject-EBInstanceProfile-11111EXAMPLE"}

6. Wählen Sie im Bereich zum Bearbeiten der Stufe die Option Cancel (Abbrechen).

80



So erstellen Sie eine Aktion "GenerateChangeSet" in Ihrer neuen Prod-StufeNote

Wenn Sie die neue Aktion, nachdem Sie sie hinzugefügt haben, erneut zur Bearbeitung öffnen,während Sie sich noch im Bearbeitungsmodus befinden, werden einige Felder möglicherweisenicht angezeigt werden. Möglicherweise erscheint auch die folgende Meldung: Stack Stack-Nameist nicht vorhandenDieser Fehler hindert Sie nicht am Speichern der Pipeline. Um die fehlenden Felder jedochwiederherzustellen, müssen Sie die neue Aktion löschen und erneut hinzufügen. Nachdem Sie diePipeline gespeichert und ausgeführt haben, wird der Stack erkannt, und der Fehler tritt nicht mehrauf.

1. Wenn Ihre Pipeline nicht bereits angezeigt wird, wählen Sie in Ihrem AWS CodeStar-Projekt-Dashboard Pipeline Details (Pipeline-Details), um Ihre Pipeline in der Konsole zu öffnen.

2. Wählen Sie Edit (Bearbeiten) aus.3. Wählen Sie unten im Diagramm + Add stage (+ Stufe hinzufügen) aus.4. Geben Sie einen Namen für die Stufe ein (zum Beispiel Prod) und wählen Sie dann + Add action

group (+ Aktionsgruppe hinzufügen).5. Geben Sie im Feld Action name (Name der Aktion) einen Namen ein (zum Beispiel

GenerateChangeSet).6. Wählen Sie unter Action provider (Aktionsanbieter) die Option AWS CloudFormation.7. Wählen Sie unter Action mode (Aktionsmodus) die Option Create or replace a change set (Einen

Änderungssatz erstellen oder ersetzen) aus.8. Geben Sie in Stack name (Name des Stacks) einen neuen Namen für den AWS CloudFormation-

Stack ein, der durch diese Aktion erstellt werden soll. Beginnen Sie mit einem Namen, der mit demBereitstellungs-Stack-Namen identisch ist, und fügen Sie dann -prod hinzu:

• Lambda-Projekte: awscodestar-<project_name>-lambda-prod• Amazon EC2- und Elastic Beanstalk-Projekte: awscodestar-<project_name>-infrastructure-prod

Note

Der Stack-Name muss genau mit awscodestar-<project_name>- beginnen oder dieStack-Erstellung schlägt fehl.

9. Geben Sie unter Change set name (Name des Änderungssatzes) den gleichen Namen desÄnderungssatzes ein wie in der vorhandenen Bereitstellungsstufe (zum Beispiel pipeline-changeset).

10. Geben Sie unter Template (Vorlage) den gleichen Namen zur Änderung der Vorlageein wie in der vorhandenen Bereitstellungsstufe (zum Beispiel <project-ID>-BuildArtifact::template.yml).

11. Geben Sie unter Template configuration (Vorlagenkonfiguration) den gleichen Namen derÄnderungsvorlagen-Konfigurationsdatei ein, der in der Bereitstellungsstufe angegeben wird (zumBeispiel <project-ID>-BuildArtifact::template-configuration.json).

12. Wählen Sie unter Capabilities (Funktionalitäten) die Option CAPABILITY_NAMED_IAM.13. Wählen Sie unter Role name (Rollenname) den Namen der AWS CloudFormation-Auftragnehmerrolle

Ihres Projekts.14. Erweitern Sie Advanced (Erweitert) und fügen Sie unter Parameters (Parameter) die Parameter für Ihr

Projekt ein. Schließen Sie den Parameter Stage, hier im JSON-Format gezeigt, für ein Amazon EC2-Projekt ein:

{

81



"ProjectId":"MyProject", "InstanceType":"t2.micro", "WebAppInstanceProfile":"awscodestar-MyProject-WebAppInstanceProfile-EXAMPLEY5VSFS", "ImageId":"ami-EXAMPLE1", "KeyPairName":"my-keypair", "SubnetId":"subnet-EXAMPLE", "VpcId":"vpc-EXAMPLE1", "Stage":"Prod"}

Note

Achten Sie darauf, dass Sie alle Parameter für das Projekt einfügen, nicht nur neueParameter oder Parameter, die Sie ändern möchten.

15. Wählen Sie unter Input artifacts (Eingabeartefakte) den Build-Artefakt.16. Wählen Sie Save aus.17. Wählen Sie im Bereich AWS CodePipeline die Option Save pipeline change (Pipeline-Änderung

speichern) und dann Save change (Änderung speichern). Sehen Sie sich Ihre aktualisierte Pipeline an.

So erstellen Sie eine ExecuteChangeSet-Aktion in Ihrer neuen Prod-Stufe

1. Wenn Ihre Pipeline nicht bereits angezeigt wird, wählen Sie in Ihrem AWS CodeStar-Projekt-Dashboard Pipeline Details (Pipeline-Details), um Ihre Pipeline in der Konsole zu öffnen.

2. Wählen Sie Edit (Bearbeiten) aus.3. Wählen Sie in Ihrer neuen Prod-Stufe nach der Aktion GenerateChangeSet die Option + Add action

group (+ Aktionsgruppe hinzufügen).4. Geben Sie im Feld Action name (Name der Aktion) einen Namen ein (zum Beispiel

ExecuteChangeSet).5. Wählen Sie unter Action provider (Aktionsanbieter) die Option AWS CloudFormation.6. Wählen Sie unter Action mode (Aktionsmodus) die Option Execute a change set (Einen Änderungssatz

ausführen).7. Geben Sie unter Stack name (Name des Stacks) den neuen Namen für den AWS CloudFormation-

Stack ein, den Sie in der Aktion GenerateChangeSet eingegeben haben (zum Beispielawscodestar-<project-ID>-infrastructure-prod).

8. Geben Sie unter Change set name (Name des Änderungssatzes) den gleichen Namen desÄnderungssatzes ein wie in der Bereitstellungsstufe (zum Beispiel pipeline-changeset).

9. Wählen Sie Save aus.10. Wählen Sie im Bereich AWS CodePipeline die Option Save pipeline change (Pipeline-Änderung


So erstellen Sie eine CodeDeploy-Bereitstellungsaktion in Ihrer neuen Prod-Stufe (nur AmazonEC2-Projekte)

1. Wählen Sie nach den neuen Aktionen in Ihrer Prod-Stufe + Action (+ Aktion).2. Geben Sie im Feld Action name (Name der Aktion) einen Namen ein (zum Beispiel Deploy).3. Wählen Sie unter Action provider (Aktionsanbieter) die Option AWS CodeDeploy.4. Wählen Sie unter Application name (Anwendungsname) den Namen der neuen CodeDeploy-

Anwendung, die Sie in Schritt 2 erstellt haben.5. Wählen Sie unter Deployment group (Bereitstellungsgruppe) den Namen der neuen CodeDeploy-

Bereitstellungsgruppe, die Sie in Schritt 2 erstellt haben.6. Wählen Sie in Input Artifacts (Eingabeartefakte) den gleichen Build-Artefakt, der in der bestehenden

Stufe verwendet wird.

82



7. Wählen Sie Save aus.8. Wählen Sie im Bereich AWS CodePipeline die Option Save pipeline change (Pipeline-Änderung


Schritt 3: Hinzufügen einer manuellen GenehmigungsstufeAls bewährte Methode empfiehlt es sich, vor Ihrer neuen Produktionsstufe eine manuelleGenehmigungsstufe hinzuzufügen.

1. Wählen Sie links oben Edit (Bearbeiten) aus.2. Wählen Sie in Ihrem Pipeline-Diagramm zwischen den Bereitstellungsstufen "Bereitstellen" und "Prod"

+Add stage (+ Stufe hinzufügen).3. Geben Sie unter Edit stage (Stufe bearbeiten) einen Namen für die Stufe ein (zum Beispiel Approval)

und wählen Sie dann + Add action group (+ Aktionsgruppe hinzufügen).4. Geben Sie im Feld Action name (Name der Aktion) einen Namen ein (zum Beispiel Approval).5. Wählen Sie in Approval type Manual approval aus.6. (Optional) Wählen Sie unter Configuration (Konfiguration) in SNS Topic ARN (SNS-Thema-ARN) das

SNS-Thema, das Sie erstellt und abonniert haben.7. Wählen Sie Add Action (Aktion hinzufügen) aus.8. Wählen Sie im Bereich AWS CodePipeline die Option Save pipeline change (Pipeline-Änderung

speichern) und dann Save change (Änderung speichern). Sehen Sie sich Ihre aktualisierte Pipeline an.9. Um Ihre Änderungen zu übertragen und einen Pipeline-Build zu starten, wählen Sie Release change

(Änderung freigeben) und dann Release (Freigeben).

Schritt 4: Übertragen einer Änderung und Überwachen der AWSCloudFormation-Stack-Aktualisierung1. Nehmen Sie eine Änderung in Ihrem Repository zum Starten Ihrer Pipeline vor.2. Wenn die Pipeline mit der Bereitstellungsstufe beginnt, wird das Update des AWS CloudFormation-

Stacks gestartet. Sie können die AWS CloudFormation-Stufe in Ihrer Pipeline auf Ihrem AWSCodeStar Dashboard auswählen, um Benachrichtigung über die Aktualisierung des Stacks zu sehen.Um Details der Stack-Erstellung anzuzeigen, wählen Sie in der Konsole Ihr Projekt aus der ListeEvents (Ereignisse) aus.

3. Nach einem erfolgreichen Abschluss Ihrer Pipeline werden die Ressourcen in Ihrem AWSCloudFormation-Stack angelegt. Wählen Sie in der AWS CloudFormation-Konsole den Infrastruktur-Stack für Ihr Projekt. Stack-Namen weisen das folgende Format auf:

• Lambda-Projekte: awscodestar-<project_name>-lambda-prod• Amazon EC2- und Elastic Beanstalk-Projekte: awscodestar-<project_name>-infrastructure-prod

Zeigen Sie in der Liste Resources (Ressourcen) in der AWS CloudFormation-Konsole die Ressourcean, die für Ihr Projekt erstellt wurde. In diesem Beispiel wird die neue Amazon EC2-Instance imAbschnitt Resources (Ressourcen) angezeigt.

4. Greifen Sie auf den Endpunkt für Ihre Produktionsstufe zu:

• Öffnen Sie für ein Elastic Beanstalk-Projekt den neuen Stack in der AWS CloudFormation-Konsoleund erweitern Sie Resources (Ressourcen). Wählen Sie die Elastic Beanstalk-Anwendung. Der Linköffnet sich in der Elastic Beanstalk-Konsole. Wählen Sie Environment (Umgebung). Wählen Sie denURL in URL zum Öffnen des Endpunkts in einem Browser.

83

AWS CodeStar BenutzerhandbuchSicheres Verwenden von SSM-Parametern

in einem AWS CodeStar-Projekt

• Öffnen Sie für ein Lambda-Projekt den neuen Stack in der AWS CloudFormation-Konsole underweitern Sie Resources (Ressourcen). Wählen Sie die Ressource API Gateway. Der Link öffnetsich in der API Gateway-Konsole. Wählen Sie Stages. Wählen Sie den URL in Invoke URL (Aufruf-URL) zum Öffnen des Endpunkts in einem Browser.

• Wählen Sie bei einem Amazon EC2-Projekt die neue Amazon EC2-Instance in IhrerProjektressourcenliste in der AWS CodeStar-Konsole. Der Link öffnet sich auf der Seite Instance derAmazon EC2-Konsole. Wählen Sie die Registerkarte Description (Beschreibung), kopieren Sie denURL in Public DNS (IPv4) (Öffentliches DNS (IPv4)) und öffnen Sie den URL in einem Browser.

5. Überprüfen Sie, ob Ihre Änderung bereitgestellt wird.

Sicheres Verwenden von SSM-Parametern in einemAWS CodeStar-ProjektViele Kunden speichern vertrauliche Daten, wie z. B. Anmeldeinformationen, in Parametern im SystemsManager-Parameterspeicher. Jetzt können Sie diese Parameter sicher in einem AWS CodeStar-Projektverwenden. Sie können beispielsweise SSM-Parameter in Ihrer Build-Spezifikation für CodeBuildverwenden oder beim Definieren von Anwendungs-Ressourcen in Ihrem Toolchain-Stack (template.yml).

Um die SSM-Parameter in einem AWS CodeStar-Projekt verwenden zu können, müssen Sie die Parametermanuell mit dem AWS CodeStar-Projekt ARN markieren. Sie müssen der AWS CodeStar-Toolchain-Workerrolle auch die entsprechenden Berechtigungen für den Zugriff auf die von Ihnen markiertenParameter erteilen.

Bevor Sie beginnen• Erstellen Sie einen neuen oder identifizieren Sie einen vorhandenen Systems Manager-Parameter, der

die Informationen enthält, auf die Sie zugreifen möchten.• Identifizieren Sie das AWS CodeStar-Projekt, das Sie verwenden möchten, oder erstellen Sie ein neues

Projekt (p. 49).• Notieren Sie den CodeStar-Projekt-ARN. Er sollte wie folgt aussehen: arn:aws:codestar:region-id:account-id:project/project-id.

Markieren eines Parameters mit dem AWS CodeStar-Projekt-ARNSchritt-für-Schritt-Anweisungen finden Sie unter Markieren von Systems Manager-Parametern.

1. Geben Sie für Key (Schlüssel) awscodestar:projectArn ein.2. Geben Sie in das Feld Value (Wert) den Projekt-ARN von CodeStar ein:

arn:aws:codestar:region-id:account-id:project/project-id.3. Wählen Sie Save aus.

Jetzt können Sie auf den SSM-Parameter in Ihrer template.yml-Datei verweisen. Wenn Sie sie mit einerToolchain-Workerrolle verwenden möchten, müssen Sie weitere Berechtigungen erteilen.

Gewähren von Berechtigungen zum Verwenden markierterParameter in Ihrer AWS CodeStar-Projekt-Toolchain

Note

Diese Schritte gelten nur für Projekte, die nach dem 6. Dezember 2018 PDT erstellt wurden.

84

https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-about.html

https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-about.html

https://docs.aws.amazon.com/systems-manager/latest/userguide/param-create-console.html

https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-paramstore-su-tag.html

AWS CodeStar BenutzerhandbuchShift Traffic für ein AWS Lambda-Projekt

1. Öffnen Sie das AWS CodeStar-Projekt-Dashboard für das Projekt, das Sie verwenden möchten.2. Klicken Sie auf Project (Projekt), um die Liste der erstellten Ressourcen anzeigen. Suchen Sie die

Toolchain-Workerrolle. Es handelt sich um eine IAM-Ressource mit einem Namen im Format: role/CodeStarWorker-project-id-ToolChain.

3. Klicken Sie auf den ARN, um ihn in der IAM-Konsole zu öffnen.4. Suchen Sie die ToolChainWorkerPolicy und erweitern Sie sie, falls erforderlich.5. Wählen Sie Edit policy (Richtlinie bearbeiten) aus.6. Fügen Sie unter Action: die folgende Zeile hinzu:

ssm:GetParameter*

7. Klicken Sie auf "Review policy (Richtlinie überprüfen)" und danach auf "Save changes (Änderungenspeichern)".

Für Projekte, die vor dem 6. Dezember 2018 PDT erstellt wurden, müssen Sie zu den Workerrollen fürjeden Service die folgenden Berechtigungen hinzufügen.

{ "Action": [ "ssm:GetParameter*" ], "Resource": "*", "Effect": "Allow", "Condition": { "StringEquals": { "ssm:ResourceTag/awscodestar:projectArn": "arn:aws:codestar:region-id:account-id:project/project-id" } } }

Shift Traffic für ein AWS Lambda-ProjektAWS CodeDeploy unterstützt Funktionsversion Bereitstellungen für AWS Lambda-Funktionen in Ihren AWSCodeStar serverlosen Projekten. Eine AWS Lambda-Bereitstellung verlagert eingehenden Datenverkehrvon einer vorhandenen Lambda-Funktion auf eine aktualisierte Lambda-Funktionsversion. Möglicherweisemöchten Sie eine aktualisierte Lambda-Funktion testen, indem Sie eine separate Version bereitstellen unddann die Bereitstellung bei Bedarf auf die erste Version zurücksetzen.

Verwenden Sie die Schritte in diesem Abschnitt, um Ihre AWS CodeStar-Projektvorlage zu ändern unddie IAM-Berechtigungen Ihrer CodeStarWorker-Rollen zu aktualisieren. Diese Aufgabe startet eineautomatisierte Antwort in AWS CloudFormation, die aliasierte AWS Lambda-Funktionen erstellt und dannAWS CodeDeploy anweist, den Datenverkehr auf eine aktualisierte Umgebung zu verlagern.

Note

Führen Sie diese Schritte nur dann aus, wenn Sie Ihr AWS CodeStar Projekt vor12. Dezember 2018 angelegt haben.

AWS CodeDeploy verfügt über drei Bereitstellungsoptionen, mit denen Sie den Traffic auf Versionen IhrerAWS Lambda-Funktion in Ihrer Anwendung verlagern können:

• Canary: Der Datenverkehr wird in zwei Inkrementen verschoben. Sie können aus vordefinierten Canary-Optionen wählen, die den Prozentsatz des Verkehrs angeben, der sich im ersten Schritt auf Ihre

85


aktualisierte Lambda-Funktionsversion und das Intervall in Minuten vor der Verschiebung des restlichenVerkehrs im zweiten Schritt verschoben hat.

• Linear: Der Datenverkehr wird in gleich großen Inkrementen mit einer gleichen Anzahl von Minutenzwischen den Inkrementen verschoben. Sie können aus vordefinierten linearen Optionen wählen, die denprozentualen Anteil des Datenverkehrs angeben, der in jedem Inkrementschritt verschoben wird, sowiedie Anzahl der Minuten zwischen den einzelnen Inkrementschritten. Der Datenverkehr wird in gleichgroßen Inkrementen mit einer gleichen Anzahl von Minuten zwischen den Inkrementen verschoben. Siekönnen aus vordefinierten linearen Optionen wählen, die den prozentualen Anteil des Datenverkehrsangeben, der in jedem Inkrementschritt verschoben wird, sowie die Anzahl der Minuten zwischen deneinzelnen Inkrementschritten.

• Alle auf einmal: Der gesamte Datenverkehr wird von der ursprünglichen Lambda-Funktion auf einmal zuder aktualisierten Lambda-Funktionsversion verschoben.

Bereitstellungspräferenztyp

Canary10Percent30Minutes




Linear10PercentEvery10Minutes

Linear10PercentEvery1Minute



AllAtOnce

Weitere Informationen zu AWS CodeDeploy-Bereitstellungen auf einer AWS Lambda-Compute-Plattformfinden Sie unter Bereitstellungen auf einer AWS Lambda-Datenverarbeitungsplattform.

Weitere Informationen über AWS SAM finden Sie unter AWS Serverless Application Model (AWS SAM) aufGitHub.

Voraussetzungen:

Wenn Sie ein serverloses Projekt erstellen, wählen Sie eine beliebige Vorlage mit der Lambda-Compute-Plattform. Sie müssen als Administrator angemeldet sein, um die Schritte 4-6 ausführen zu können.

Schritt 1: Ändern Sie die SAM-Vorlage, um AWS Lambda Versionsbereitstellungsparameterhinzuzufügen.

1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar.2. Erstellen Sie ein Projekt oder wählen Sie ein bestehendes Projekt mit einer template.yml-Datei,

und öffnen Sie dann die Seite Code. Notieren Sie sich in der obersten Ebene Ihres Repositorys denSpeicherort der SAM-Vorlage mit dem Namen template.yml, die geändert werden soll.

3. Öffnen Sie die template.yml-Datei in Ihrer IDE oder dem lokalen Repository. Kopieren Sie denfolgenden Text, um einen Abschnitt Globals zur Datei hinzuzufügen. Der Beispieltext in diesemTutorial wählt die Option Canary10Percent5Minutes.

Globals:

86

https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps.html#deployment-steps-lambda

https://github.com/awslabs/serverless-application-model



Function: AutoPublishAlias: live DeploymentPreference: Enabled: true Type: Canary10Percent5Minutes

Dieses Beispiel zeigt eine geänderte Vorlage, nachdem der Globals-Abschnitt hinzugefügt wurde:

Weitere Informationen finden Sie unter Abschnitt Global im Referenzhandbuch für SAM-Vorlagen.

Schritt 2: Bearbeiten der AWS CloudFormation-Rolle, um Berechtigungen hinzuzufügen.


Note

Sie müssen sich bei der AWS Management Console unter Verwendung derAnmeldeinformationen des IAM-Benutzers anmelden, den Sie in Einrichten von AWSCodeStar (p. 3) erstellt oder identifiziert haben. Diesem Benutzer muss die verwaltete AWS-Richtlinie mit dem Namen AWSCodeStarFullAccess zugeordnet sein.

2. Wählen Sie Ihr bestehendes serverloses Projekt und öffnen Sie dann die Seite Project resources(Projektressourcen).

3. Wählen Sie unter Resources (Ressourcen) die IAM-Rolle, die für die CodeStarWorker/AWSCloudFormation-Rolle erstellt wurde. Die Rolle öffnet sich in der IAM-Konsole.

4. Wählen Sie auf der Registerkarte Permissions im Bereich Inline Policies in der Zeile für IhreServicerollen-Richtlinie die Option Edit Policy aus. Wählen Sie die Registerkarte JSON, um dieRichtlinie im JSON-Format zu bearbeiten.

Note

Ihre Servicerolle hat den Namen CodeStarWorkerCloudFormationRolePolicy.5. Fügen Sie im Feld JSON die folgenden Richtlinienanweisungen in das Element Statement ein.

Ersetzen Sie die Platzhalter region und id durch Ihre Region und Ihre Konto-ID.

{ "Action": [ "s3:GetObject",

87

https://github.com/awslabs/serverless-application-model/blob/master/docs/globals.rst



"s3:GetObjectVersion", "s3:GetBucketVersioning" ], "Resource": "*", "Effect": "Allow"},{ "Action": [ "s3:PutObject" ], "Resource": [ "arn:aws:s3:::codepipeline*" ], "Effect": "Allow"},{ "Action": [ "lambda:*" ], "Resource": [ "arn:aws:lambda:region:id:function:*" ], "Effect": "Allow"},{ "Action": [ "apigateway:*" ], "Resource": [ "arn:aws:apigateway:region::*" ], "Effect": "Allow"},{ "Action": [ "iam:GetRole", "iam:CreateRole", "iam:DeleteRole", "iam:PutRolePolicy" ], "Resource": [ "arn:aws:iam::id:role/*" ], "Effect": "Allow"},{ "Action": [ "iam:AttachRolePolicy", "iam:DeleteRolePolicy", "iam:DetachRolePolicy" ], "Resource": [ "arn:aws:iam::id:role/*" ], "Effect": "Allow"},{ "Action": [ "iam:PassRole" ], "Resource": [ "*" ], "Effect": "Allow"},{

88


"Action": [ "codedeploy:CreateApplication", "codedeploy:DeleteApplication", "codedeploy:RegisterApplicationRevision" ], "Resource": [ "arn:aws:codedeploy:region:id:application:*" ], "Effect": "Allow"},{ "Action": [ "codedeploy:CreateDeploymentGroup", "codedeploy:CreateDeployment", "codedeploy:DeleteDeploymentGroup", "codedeploy:GetDeployment" ], "Resource": [ "arn:aws:codedeploy:region:id:deploymentgroup:*" ], "Effect": "Allow"},{ "Action": [ "codedeploy:GetDeploymentConfig" ], "Resource": [ "arn:aws:codedeploy:region:id:deploymentconfig:*" ], "Effect": "Allow"}

6. Wählen Sie Review policy, um sicherzustellen, dass die Richtlinie keine Fehler enthält. Ist die Richtliniefehlerfrei, klicken Sie auf Save changes.

Schritt 3: Commit und Push Ihrer Vorlagenänderung, um die AWS Lambda-Versionsverschiebungzu starten.

1. Übertragen und verschieben Sie die Änderungen in der Datei template.yml, die Sie in Schritt 1gespeichert haben.

Note

Dadurch wird Ihre Pipeline gestartet. Wenn Sie die Änderungen übertragen, bevor Sie dieIAM-Berechtigungen aktualisieren, startet Ihre Pipeline und das AWS CloudFormation-Stack-Update stößt auf Fehler, wodurch das Stack-Update zurückgesetzt wird. Starten Sie in diesemFall Ihre Pipeline neu, nachdem die Berechtigungen korrigiert wurden.

2. Das Update des AWS CloudFormation-Stacks startet, wenn die Pipeline für Ihr Projekt mit derBereitstellungsphase beginnt. Um die Benachrichtigung über die Stapelaktualisierung beim Startder Bereitstellung zu sehen, wählen Sie in Ihrem AWS CodeStar-Dashboard die Phase AWSCloudFormation in Ihrer Pipeline aus.

Während der Stapelaktualisierung aktualisiert AWS CloudFormation automatisch dieProjektressourcen wie folgt:

• AWS CloudFormation verarbeitet die template.yml-Datei, indem Sie alialisierte Lambda-Funktionen, Ereignis-Hooks und Ressourcen erstellt.

• AWS CloudFormation ruft Lambda auf, um die neue Version der Funktion zu erstellen.• AWS CloudFormation erstellt eine AppSpec-Datei und ruft AWS CodeDeploy auf, um den

Datenverkehr umzuleiten.

89

AWS CodeStar BenutzerhandbuchÜbergang Ihres AWS CodeStar-Projekts in die Produktion

Weitere Informationen über das Veröffentlichen von Alias in SAM finden Sie unter Lambda-Funktionendie Vorlage des serverlosen Anwendungsmodellstandards ( AWS Serverless Application Model,AWS SAM) verweisen. Weitere Informationen über Ereignis-Hooks und Ressourcen in der AWSCodeDeploy-Datei AppSpec finden Sie unter AppSpec 'resources' Abschnitt (nur AWS Lambda-Bereitstellungen) und AppSpec 'hooks' Abschnitt für eine AWS Lambda-Bereitstellung.

3. Nach einem erfolgreichen Abschluss Ihrer Pipeline werden die Ressourcen in Ihrem AWSCloudFormation-Stack angelegt. Zeigen Sie auf der Seite Project (Projekt) in der Liste der ProjectResources (Projektressourcen) die AWS CodeDeploy-Anwendung, die AWS CodeDeploy-Bereitstellungsgruppe und die für Ihr Projekt erstellten AWS CodeDeploy-Ressourcen der Servicerollean.

4. Um eine neue Version zu erstellen, nehmen Sie eine Änderung an der Lambda-Funktion in IhremRepository vor. Die neue Bereitstellung startet und verschiebt den Datenverkehr entsprechend demin der SAM-Vorlage angegebenen Bereitstellungstyp. Um den Status des Traffics anzuzeigen, der aufdie neue Version verschoben wird, wählen Sie auf der Seite Project (Projekt), in der Liste der ProjectResources (Projektressourcen), den Link zur AWS CodeDeploy-Bereitstellung.

5. Um Details zu jeder Revision anzuzeigen, wählen Sie unter Revisions (Revisionen) den Link zur AWSCodeDeploy-Bereitstellungsgruppe.

6. In Ihrem lokalen Arbeitsverzeichnis können Sie Änderungen an Ihrer AWS Lambda-Funktionvornehmen und die Änderung in Ihr Projektarchiv übertragen. AWS CloudFormation unterstütztAWS CodeDeploy bei der Verwaltung der nächsten Revision auf die gleiche Weise. WeitereInformationen zum Umsetzen, Stoppen oder Zurücksetzen einer Lambda-Bereitstellung finden Sieunter Bereitstellungen auf einer AWS Lambda-Datenverarbeitungsplattform.

Übergang Ihres AWS CodeStar-Projekts in dieProduktion

Nachdem Sie Ihre Anwendung mit einem AWS CodeStar-Projekt erstellt und AWS CodeStar kennengelernthaben, ist Ihr Projekt für die Nutzung in der Produktionsumgebung bereit. Eine Möglichkeit besteht darin,die AWS-Ressourcen Ihrer Anwendung außerhalb von AWS CodeStar zu replizieren. Sie benötigenweiterhin ein Repository, ein Build-Projekt, eine Pipeline und eine Bereitstellung. Diese werden jedoch nichtmit AWS CodeStar erstellt, sonder mit AWS CloudFormation neu erstellt.

Note

Es kann hilfreich sein, ein ähnliches Projekt mit einem der AWS CodeStar-Schnellstarts zuerstellen oder anzuzeigen und dieses als Vorlage für Ihr eigenes Projekt zu verwenden, umsicherzustellen, dass Sie die erforderlichen Ressourcen und Richtlinien berücksichtigen.

Ein AWS CodeStar Projekt ist eine Kombination aus Quellcode und erstellten Ressourcen, um den Codebereitzustellen. Die Sammlung von Ressourcen, die Ihnen bei der Erstellung, Freigabe und BereitstellungIhres Codes helfen, werden Toolchain-Ressourcen genannt. Bei der Projekterstellung stellt eine AWSCloudFormation-Vorlage Ihre Toolchain-Ressourcen in einer CI/CD-Pipeline (Continuous Integration/Continuous Deployment) bereit.

Wenn Sie die Konsole zum Erstellen eines Projekts verwenden, wird die Toolchain-Vorlage für Sie erstellt.Wenn Sie die AWS CLI zum Erstellen eines Projekts verwenden, erstellen Sie die Toolchain-Vorlage, dieIhre Toolchain-Ressourcen erstellt.

Eine vollständige Toolchain benötigt die folgenden empfohlenen Ressourcen:

1. Ein CodeCommit- oder GitHub-Repository, das Ihren Quellcode enthält.2. Eine CodePipeline-Pipeline, die zum Verfolgen von Änderungen an Ihrem Repository konfiguriert ist.

90

https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md

https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-resources.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-resources.html

https://docs.aws.amazon.com/codedeploy/latest/userguide/reference-appspec-file-structure-hooks.html#appspec-hooks-lambda

https://docs.aws.amazon.com/codedeploy/latest/userguide/deployment-steps.html#deployment-steps-lambda

AWS CodeStar BenutzerhandbuchErstellen eines GitHub-Repositorys

a. Wenn Sie AWS CodeBuild verwenden, um Komponenten- oder Integrationstests durchzuführen,empfehlen wir Ihnen, Ihrer Pipeline eine Build-Stage hinzuzufügen, um Build-Artefakte zu erstellen.

b. Wir empfehlen Ihnen, Ihrer Pipeline eine Bereitstellungsphase hinzuzufügen, die CodeDeployoder AWS CloudFormation verwendet, um Ihr Build-Artefakt und Ihren Quellcode in IhrerLaufzeitinfrastruktur bereitzustellen.

Note

Da CodePipeline mindestens zwei Stufen in einer Pipeline erfordert und die erste Stufe dieQuellstufe sein muss, fügen Sie eine Build- oder eine Bereitstellungsstufe als zweite Stufehinzu.

Themen• Erstellen eines GitHub-Repositorys (p. 91)

Erstellen eines GitHub-RepositorysSie erstellen ein GitHub-Repository, indem Sie es in Ihrer Toolchain-Vorlage definieren. Sie müssenbereits einen Speicherort für eine ZIP-Datei mit Ihrem Quellcode erstellt haben, damit der Code in dasRepository hochgeladen werden kann. Außerdem müssen Sie bereits ein persönliches Zugriffstoken inGitHub erstellt haben, damit AWS in Ihrem Namen eine Verbindung mit GitHub aufbauen kann. Zusätzlichzum persönlichen Zugriffstoken für GitHub müssen Sie auch über die s3.GetObject-Berechtigung für daszu übergebende Code-Objekt verfügen.

Um ein öffentliches GitHub-Repository anzugeben, fügen Sie Ihrer Toolchain-Vorlage in AWSCloudFormation Code wie den folgenden hinzu.

GitHubRepo: Condition: CreateGitHubRepo Description: GitHub repository for application source code Properties: Code: S3: Bucket: MyCodeS3Bucket Key: MyCodeS3BucketKey EnableIssues: true IsPrivate: false RepositoryAccessToken: MyGitHubPersonalAccessToken RepositoryDescription: MyAppCodeRepository RepositoryName: MyAppSource RepositoryOwner: MyGitHubUserName Type: AWS::CodeStar::GitHubRepository

Dieser Code enthält die folgenden Informationen:

• Der Speicherort des Codes, den Sie berücksichtigen möchten. Dieser muss ein Amazon S3-Bucket sein.• Gibt an, ob Sie Probleme im GitHub-Repository aktivieren möchten.• Gibt an, ob das GitHub-Repository privat ist.• Das persönliche GitHub-Zugriffstoken, das Sie erstellt haben.• Beschreibung, Name und Eigentümer des Repositorys, das Sie erstellen.

Ausführliche Informationen zu den anzugebenden Informationen finden Sie unterAWS::CodeStar::GitHubRepository im AWS CloudFormation Benutzerhandbuch.

91

https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codestar-githubrepository.html

AWS CodeStar BenutzerhandbuchArbeiten mit Projekt-Tags

Arbeiten mit Projekt-Tags in AWS CodeStarSie können Projekten in AWS CodeStar Tags zuordnen. Tags unterstützen Sie bei der Verwaltung IhrerProjekte. Sie könnten beispielsweise ein Tag mit dem Schlüssel Release und dem Wert Beta für jedesProjekt hinzufügen, das Ihre Organisation für eine Beta-Version bearbeitet.

Einem Projekt ein Tag hinzufügen1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im Navigationsfenster Project

(Projekt).2. Geben Sie für Create new tag (Neuen Tag erstellen), in Key (Schlüssel), den Namen des Tags ein.

Geben Sie in das Feld Value (Wert) den Wert des Tags ein.3. Wählen Sie Add tag aus.

Ein Tag von einem Projekt entfernen1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im Navigationsfenster Project

(Projekt).2. Suchen Sie im Bereich Tags unter Current tags (Aktuelle Tags) das Tag, das Sie entfernen wollen.3. Wählen Sie in der Spalte Options (Optionen) für dieses Tag Remove (Entfernen) aus.

Note

Sie haben ungefähr drei Sekunden Zeit, um das Löschen rückgängig zu machen. Um das Tagbeizubehalten, wählen Sie Undo (Rückgängig).Andernfalls wird das Tag endgültig gelöscht.

Abrufen einer Tag-Liste für ein ProjektFühren Sie mit der AWS CLI den AWS CodeStar-Befehl list-tags-for-project aus und geben Sie den Namendes Projekts an:

aws codestar list-tags-for-project --id my-first-projec

Ist der Befehl erfolgreich, gibt er als Tag-Liste als Ausgabe zurück, die wie folgt aussehen sollte:

{ "tags": { "Release": "Beta" }}

Löschen eines AWS CodeStar-ProjektsWenn Sie ein Projekt nicht mehr benötigen, können Sie es zusammen mit seinen Ressourcen löschen,so dass keine weiteren Änderungen in AWS mehr auftreten. Wenn Sie ein Projekt löschen, werdenalle Teammitglieder aus diesem Projekt entfernt. Deren Projektrollen werden von ihren IAM-Benutzernentfernt, ihre Benutzerprofile in AWS CodeStar werden jedoch nicht geändert. Sie können ein Projekt unterVerwendung der AWS CodeStar-Konsole oder der AWS CLI löschen.

92

AWS CodeStar BenutzerhandbuchLöschen eines Projekts in AWS CodeStar (Konsole)

Important

Das Löschen eines Projekts in AWS CodeStar kann nicht rückgängig gemacht werden.Standardmäßig werden alle AWS-Ressourcen für das Projekt in Ihrem AWS-Konto gelöscht,einschließlich:

• Das CodeCommit Repository für das Projekt zusammen mit Daten in diesem Repository.• Die AWS CodeStar-Projektrollen und die zugehörigen konfigurierten IAM-Richtlinien für das

Projekt und seine Ressourcen.• Alle für das Projekt erstellten Amazon EC2-Instances.• Die Bereitstellungsanwendung und die zugehörigen Ressourcen, wie etwa:

• Eine CodeDeploy-Anwendung und zugehörige Bereitstellungsgruppen.• Eine AWS Lambda-Funktion und die zugehörigen API Gateway-APIs.• Eine AWS Elastic Beanstalk-Anwendung und die zugehörige Umgebung.

• Die Pipeline für die kontinuierliche Bereitstellung für das Projekt in CodePipeline.• Die zu dem Projekt gehörenden AWS CloudFormation-Stacks.• Jede AWS Cloud9-Entwicklungsumgebung, die mit der AWS CodeStar-Konsole erstellt wurde.

Alle nicht bestätigten Code-Änderungen in den Umgebungen gehen verloren.

Um alle Projektressourcen zusammen mit dem Projekt zu löschen, markieren Sie dasKontrollkästchen Delete associated resources along with AWS CodeStar project (Allezugeordneten Ressourcen zusammen mit dem AWS CodeStar-Projekt löschen). Wenn Siediese Option deaktivieren, wird das Projekt in AWS CodeStar gelöscht, die Projektrollen, dieden Zugriff auf diese Ressourcen ermöglicht haben, werden ebenfalls in IAM gelöscht, alleanderen Ressourcen bleiben jedoch erhalten. Es kann sein, dass für diese Ressourcen in AWSweiterhin Änderungen auftreten. Wenn Sie sich entscheiden, dass Sie eine oder mehrere dieserRessourcen nicht behalten möchten, müssen Sie sie manuell löschen. Weitere Informationenfinden Sie unter Projektlöschung: Ein AWS CodeStar-Projekt wurde gelöscht, es sind jedochweiterhin Ressourcen vorhanden. (p. 148).Wenn Sie Ressourcen beim Löschen eines Projekts behalten möchten, wird empfohlen, dieListe der Ressourcen von der Projektdetailseite zu kopieren. Auf diese Weise haben Sie eineAufzeichnung aller Ressourcen, die Sie behalten, auch wenn das Projekt nicht mehr vorhandenist.

Themen• Löschen eines Projekts in AWS CodeStar (Konsole) (p. 93)• Löschen eines Projekts in AWS CodeStar (AWS CLI) (p. 94)

Löschen eines Projekts in AWS CodeStar (Konsole)Sie können ein Projekt unter Verwendung der AWS CodeStar-Konsole löschen.


1. Öffnen Sie die AWS CodeStar-Konsole unter https://console.aws.amazon.com/codestar/.2. Suchen Sie das Projekt in der Liste und wählen Sie über das Ellipsenmenü (…) Delete (Löschen) aus.

Oder öffnen Sie alternativ das Projekt und wählen Sie im Navigationsbereich Project (Projekt) aus.Wählen Sie auf der Seite mit den Projektdetails Delete project (Projekt löschen) aus.

3. Geben Sie im Feld Type the following project ID to confirm (Geben Sie die folgende Projekt-ID zurBestätigung ein) die Projekt-ID ein und wählen Sie Delete (Löschen) aus.

93


AWS CodeStar BenutzerhandbuchLöschen eines Projekts in AWS CodeStar (AWS CLI)

Das Löschen eines Projekts kann einige Minuten dauern. Wenn das Projekt gelöscht wurde, wird esnicht mehr in der Liste der Projekte in der AWS CodeStar-Konsole angezeigt.

Important

Wenn Sie ein Projekt löschen, werden standardmäßig alle unter Project resources(Projektressourcen) aufgeführten Ressourcen gelöscht. Wenn Sie das Kontrollkästchendeaktivieren, bleiben die Projektressourcen erhalten. Weitere Informationen finden Siehier (p. 93).Wenn Ihr Projekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oder Elemente in Atlassian JIRA), werden diese Ressourcen nicht gelöscht, auchwenn das Kontrollkästchen aktiviert ist.Ihr Projekt kann nicht gelöscht werden, wenn irgendwelche AWS CodeStar verwaltetenRichtlinien manuell mit Rollen verknüpft wurden, die keine IAM-Benutzer sind. Wenn Sie dieverwalteten Richtlinien Ihres Projekts an die Rolle eines verbundenen Benutzers angefügthaben, müssen Sie die Richtlinie trennen, bevor Sie das Projekt löschen können. WeitereInformationen finden Sie unter ??? (p. 140).

Löschen eines Projekts in AWS CodeStar (AWS CLI)Sie können ein Projekt mit der AWS CLI löschen.


1. Führen Sie in einem Terminal (Linux, macOS, or Unix) oder der Eingabeaufforderung (Windows) denBefehl delete-project aus, wobei Sie den Namen des Projekts angeben. Beispiel zum Löschen einesProjekts mit der ID my-2nd-project:

aws codestar delete-project --id my-2nd-project

Dieser Befehl gibt etwa die folgende Ausgabe zurück:

{ "projectArn":"arn:aws:codestar:us-east-2:111111111111:project/my-2nd-project"}

2. Führen Sie den Befehl list-projects aus, und prüfen Sie, ob das gelöschte Projekt nicht mehr in derListe der Ihrem AWS-Konto zugeordneten Projekte aufgeführt wird.

aws codestar list-projects

94


Arbeiten mit AWS CodeStar-TeamsNach dem Erstellen eines Entwicklungsprojekts gewähren Sie anderen Personen Zugriff, damit Siezusammenarbeiten können. In AWS CodeStar verfügt jedes Projekt über ein Projektteam. Ein Benutzerkann mehreren AWS CodeStar-Projekten angehören und jeweils verschiedene AWS CodeStar-Rollen (unddamit unterschiedliche Berechtigungen) innehaben. In der AWS CodeStar-Konsole sehen Benutzer alle mitIhrem AWS-Konto verknüpften Projekte, sie können jedoch nur die Projekte anzeigen und bearbeiten, beidenen sie Teammitglied sind.

Teammitglieder können einen Anzeigenamen für sich auswählen. Sie können auch eine E-Mail-Adressehinzufügen, sodass andere Teammitglieder mit ihnen in Kontakt treten können. Teammitglieder, die keineEigentümer sind, können ihre AWS CodeStar-Rolle für das Projekt nicht ändern.

Jedes Projekt in AWS CodeStar verfügt über drei Rollen:

Rollen und Berechtigungen in einem AWS CodeStar-Projekt

Name der Rolle Anzeigedes Projekt-Dashboards unddes Status

Hinzufügen/Entfernen/Aufrufen vonProjektressourcen

Hinzufügen/Entfernen vonTeammitgliedern

Löschen einesProjekts

Eigentümer x x x x

Beitragender x x

Betrachter x

• Eigentümer: kann andere Teammitglieder hinzufügen und entfernen, Code zum Projekt-Repositorybeitragen, falls der Code in CodeCommit gespeichert ist, anderen Teammitgliedern den Remote-Zugriffauf alle mit dem Projekt verknüpften Amazon EC2-Instances mit Linux gewähren oder verweigern, dasProjekt-Dashboard konfigurieren und das Projekt löschen.

• Beitragender: kann Dashboard-Ressourcen, wie beispielsweise eine JIRA-Kachel, hinzufügen undentfernen, Code zum Projekt-Repository beitragen, falls der Code in CodeCommit gespeichert ist, undvollständig mit dem Dashboard interagieren. Kann nicht Teammitglieder hinzufügen oder entfernen,Remote-Zugriff auf Ressourcen gewähren oder verweigern oder das Projekt löschen. Dies ist die Rolle,die Sie für die meisten Teammitglieder wählen sollten.

• Betrachter: kann das Projekt-Dashboard, den Code, falls dieser in CodeCommit gespeichert ist, und, aufden Dashboard-Kacheln, den Status des Projekts und seiner Ressourcen anzeigen.

Important

Wenn Ihr Projekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oder Probleme in Atlassian JIRA), wird der Zugriff auf diese Ressourcen vomRessourcenanbieter kontrolliert, nicht von AWS CodeStar. Weitere Informationen finden Sie in derDokumentation des Ressourcenanbieters.Jeder, der Zugriff auf ein AWS CodeStar-Projekt hat, kann die AWS CodeStar-Konsole für denZugriff auf Ressourcen nutzen, die außerhalb von AWS liegen, aber im Zusammenhang mit demProjekt stehen.AWS CodeStar erlaubt es den Mitgliedern des Projektteams nicht automatisch, an zugehörigenAWS Cloud9-Entwicklungsumgebungen für ein Projekt teilzunehmen. Wie Sie einem Teammitglied

95

AWS CodeStar BenutzerhandbuchHinzufügen von Teammitgliedern zu einem Projekt

die Teilnahme an einer gemeinsamen Umgebung ermöglichen, erfahren Sie unter Freigeben einerAWS Cloud9-Umgebung für ein Projekt-Teammitglied (p. 60).

Eine IAM-Richtlinie wird mit allen Projektrollen verknüpft. Diese Richtlinie ist für Ihr Projekt angepasst,sodass es die enthaltenen Ressourcen widerspiegelt. Weitere Informationen zu diesen Richtlinien findenSie unter AWS CodeStar-Zugriffsberechtigungen – Referenz (p. 112).

Das folgende Diagramm zeigt die Beziehung zwischen den einzelnen Rollen und einem AWS CodeStar-Projekt.

Themen• Hinzufügen von Teammitgliedern zu einem AWS CodeStar-Projekt (p. 96)• Verwaltung von Berechtigungen für AWS CodeStar-Teammitglieder (p. 100)• Entfernen von Teammitgliedern aus einem AWS CodeStar-Projekt (p. 102)

Hinzufügen von Teammitgliedern zu einem AWSCodeStar-Projekt

Wenn Sie die Rolle des Eigentümers in einem AWS CodeStar-Projekt haben oder dieAWSCodeStarFullAccess-Richtlinie Ihrem IAM-Benutzer hinzugefügt haben, können Sie demProjektteam weitere IAM-Benutzer hinzufügen. Hierbei handelt es sich um ein einfaches Verfahren, dasdem Benutzer eine AWS CodeStar-Rolle (Eigentümer, Beitragender und Betrachter) zuweist. Diese Rollengelten pro Projekt und werden angepasst. Zum Beispiel: Ein Teammitglied mit der Rolle Beitragender inProjekt A kann Berechtigungen für Ressourcen haben, die sich von denen eines Teammitglieds mit derRolle Beitragender in Projekt B unterscheidet. Ein Teammitglied kann nur eine Rolle in einem Projekthaben. Nachdem Sie ein Teammitglied hinzugefügt haben, kann dieses sofort auf der von der Rolledefinierten Ebene mit Ihrem Projekt interagieren.

Die Vorteile von AWS CodeStar-Rollen und der Team-Mitgliedschaft sind u. a.:

96

AWS CodeStar BenutzerhandbuchEin Teammitglied hinzufügen (Konsole)

• Sie müssen nicht manuell in IAM-Berechtigungen für Ihre Teammitglieder konfigurieren.• Sie können auf einfache Weise die Zugriffsebene der Teammitglieder zu einem Projekt ändern.• Benutzer können auf Projekt-Dashboards in der AWS CodeStar-Konsole nur zugreifen, wenn sie

Teammitglieder sind.• Der Zugriff auf ein Projekt ist durch die Rolle definiert.

Informationen zu Teams und AWS CodeStar-Rollen finden Sie unter Arbeiten mit AWS CodeStar-Teams (p. 95) und Arbeiten mit Ihrem AWS CodeStar-Benutzerprofil (p. 105).

Um ein Teammitglied einem Projekt hinzufügen zu können, müssen Sie entweder über die Rolle AWSCodeStar-Eigentümer für das betreffende Projekt oder über die Richtlinie AWSCodeStarFullAccessverfügen.

Important

Das Hinzufügen eines Teammitglieds wirkt sich nicht auf den Zugriff dieses Teammitglieds aufRessourcen außerhalb von AWS aus (z. B. ein GitHub-Repository oder Elemente in AtlassianJIRA). Diese Zugriffsberechtigungen werden vom Anbieter der Ressource kontrolliert, nicht vonAWS CodeStar. Weitere Informationen finden Sie in der Dokumentation des Ressourcenanbieters.Jeder, der Zugriff auf ein AWS CodeStar-Projekt hat, kann die AWS CodeStar-Konsole für denZugriff auf Ressourcen nutzen, die außerhalb von AWS liegen, aber im Zusammenhang mitdiesem Projekt stehen.Das Hinzufügen eines Teammitglieds zu einem Projekt erlaubt es diesem nicht automatisch, anzugehörigen AWS Cloud9-Entwicklungsumgebungen für das Projekt teilzunehmen. Wie Sie einemTeammitglied die Teilnahme an einer gemeinsamen Umgebung ermöglichen, erfahren Sie unterFreigeben einer AWS Cloud9-Umgebung für ein Projekt-Teammitglied (p. 60).Wenn Sie verbundenen Benutzern Zugriff auf ein Projekt gewähren, müssen Sie die der Rolle desBenutzers entsprechenden AWS CodeStar Eigentümer, Beitragenden oder Betrachter verwaltetenRichtlinien hinzufügen. Weitere Informationen finden Sie unter Zugriff für verbundene Benutzer aufAWS CodeStar (p. 138).

Themen• Ein Teammitglied hinzufügen (Konsole) (p. 97)• Hinzufügen und Anzeigen von Teammitgliedern (AWS CLI) (p. 100)

Ein Teammitglied hinzufügen (Konsole)Sie können mithilfe der AWS CodeStar-Konsole Ihrem Projekt ein Teammitglied hinzufügen. Wenn ein IAM-Benutzer für die Person, die Sie hinzufügen möchten, bereits vorhanden ist, können Sie den IAM-Benutzerhinzufügen. Andernfalls können Sie einen IAM-Benutzer für diese Person anlegen, wenn Sie sie zu IhremProjekt hinzufügen.

So fügen Sie ein Teammitglied zu einem AWS CodeStar-Projekt (Konsole) hinzu


Wählen Sie das Projekt.2. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.3. Wählen Sie auf der Seite Team members die Option Add team member.4. Führen Sie unter Choose user einen der folgenden Schritte aus:

• Wenn ein IAM-Benutzer für die Person, die Sie hinzufügen möchten, bereits vorhanden ist, wählenSie den IAM-Benutzernamen aus der Liste aus.

97



Note

Benutzer, die bereits zu einem anderen AWS CodeStar-Projekt hinzugefügt wurden,werden in der Liste AWS CodeStar users from other projects (AWS CodeStar-Benutzer ausanderen Projekten) angezeigt.

Wählen Sie auf der Registerkarte Add team member (Teammitglied hinzufügen) in Project role(Projektrolle) die AWS CodeStar-Rolle (Eigentümer, Beitragender oder Betrachter) für diesenBenutzer aus. Dies ist eine Rolle auf AWS CodeStar-Projektebene, die nur durch einen Eigentümerdes Projekts geändert werden kann. Wenn die Rolle auf einen IAM-Benutzer angewendet wird, stelltsie alle entsprechenden Berechtigungen für den Zugriff auf AWS CodeStar-Projektressourcen bereit.Sie wendet Richtlinien an, die für das Erstellen und Verwalten von Git-Anmeldeinformationen für inCodeCommit gespeicherten Code in IAM an, oder die für das Hochladen von Amazon EC2 SSH-Schlüsseln für den Benutzer in IAM erforderlich sind.

Important

Sie können den Anzeigenamen oder die E-Mail-Informationen für einen IAM-Benutzer nurbereitstellen oder ändern, wenn Sie als dieser Benutzer bei der Konsole angemeldet sind.Weitere Informationen finden Sie unter Verwalten von Anzeigeinformationen für Ihr AWSCodeStar-Benutzerprofil (p. 105).

Wählen Sie Add aus.

• Wenn ein IAM-Benutzer für die Person, die Sie dem Projekt hinzufügen möchten, nicht existiert,wählen Sie Create new IAM user (Neuen IAM-Benutzer erstellen). Geben Sie den IAM-Benutzernamen, den AWS CodeStar-Anzeigenamen, die E-Mail-Adresse und die Projektrolle an, dieSie für diesen neuen Benutzer anwenden möchten, und wählen Sie dann Create (Erstellen).

98


Sie werden zur IAM-Konsole weitergeleitet, um die Benutzererstellung zu bestätigen. WählenSie Create user (Benutzer erstellen), speichern Sie die Passwortinformationen für diesenneuen Benutzer und klicken Sie dann auf Close (Schließen), um zur AWS CodeStar-Konsolezurückzukehren. Der Benutzer wird mit der von Ihnen gewählten Rolle zum Projekt hinzugefügt.

Note

Für eine einfachere Verwaltung sollte mindestens einem Benutzer die Eigentümer-Rolle fürdas Projekt zugewiesen sein.

5. Senden Sie dem neuen Teammitglied die folgenden Informationen:

• Verbindungsinformationen für Ihr AWS CodeStar-Projekt.• Falls der Quellcode in CodeCommit gespeichert ist, Anweisungen zum Einrichten des Zugriffs mit

Git-Anmeldeinformationen für das CodeCommit-Repository über ihren lokalen Computer.• Informationen darüber, wie Benutzer ihren Anzeigenamen, ihre E-Mail-Adresse und den öffentlichen

Amazon EC2-SSH-Schlüssel verwalten können, finden Sie unter Arbeiten mit Ihrem AWS CodeStar-Benutzerprofil (p. 105).

• Einmaliges Passwort und Verbindungsinformationen, wenn der Benutzer neu bei AWS ist und Sieeinen IAM-Benutzer für diese Person erstellt haben. Das Passwort läuft bei der ersten Anmeldungdes Benutzers ab. Der Benutzer muss ein neues Passwort auswählen.

99



AWS CodeStar BenutzerhandbuchHinzufügen und Anzeigen von Teammitgliedern (AWS CLI)

Hinzufügen und Anzeigen von Teammitgliedern (AWSCLI)Sie können Teammitglieder mithilfe der AWS CLI Ihrem Projektteam hinzufügen. Sie können auchInformationen zu allen Teammitgliedern in Ihrem Projekt anzeigen.

So fügen Sie ein Teammitglied hinzu

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den Befehl associate-team-member mit den Parametern --project-id, -user-arn

und --project-role aus. Sie können auch angeben, ob der Benutzer Remote-Zugriff auf Projekt-Instances hat, indem Sie den Parameter --remote-access-allowed oder --no-remote-access-allowed verwenden. Beispiel:

aws codestar associate-team-member --project-id my-first-projec --user-arn arn:aws:iam:111111111111:user/Jane_Doe --project-role Contributor --remote-access-allowed

Mit diesem Befehl wird keine Ausgabe zurückgegeben.

Sie zeigen Sie alle Teammitglieder an (AWS CLI):

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den list-team-members-Befehl mit dem Parameter --project-id aus. Beispiel:

aws codestar list-team-members --project-id my-first-projec


{ "teamMembers":[ {"projectRole":"Owner","remoteAccessAllowed":true,"userArn":"arn:aws:iam::111111111111:user/Mary_Major"}, {"projectRole":"Contributor","remoteAccessAllowed":true,"userArn":"arn:aws:iam::111111111111:user/Jane_Doe"}, {"projectRole":"Contributor","remoteAccessAllowed":true,"userArn":"arn:aws:iam::111111111111:user/John_Doe"}, {"projectRole":"Viewer","remoteAccessAllowed":false,"userArn":"arn:aws:iam::111111111111:user/John_Stiles"} ]}

Verwaltung von Berechtigungen für AWS CodeStar-Teammitglieder

Sie ändern die Berechtigungen für Teammitglieder, indem Sie ihre AWS CodeStar-Rolle ändern. JedemTeammitglied kann nur eine Rolle in einem AWS CodeStar-Projekt zugewiesen werden, mehrere Benutzer

100

AWS CodeStar BenutzerhandbuchTeamberechtigungen verwalten (Konsole)

können jedoch der gleichen Rolle zugewiesen werden. Sie können die AWS CodeStar-Konsole oder AWSCLI verwenden, um Berechtigungen zu verwalten.

Important

Um eine Rolle für einen Teammitglied ändern zu können, müssen Sie entweder überdie Rolle AWS CodeStar-Eigentümer für das betreffende Projekt oder über die RichtlinieAWSCodeStarFullAccess verfügen.Das Ändern der Berechtigungen eines Teammitglieds wirkt sich nicht auf den Zugriff diesesTeammitglieds auf Ressourcen außerhalb von AWS aus (z. B. ein GitHub-Repository oderProbleme in Atlassian JIRA). Diese Zugriffsberechtigungen werden vom Anbieter der Ressourcekontrolliert, nicht von AWS CodeStar. Weitere Informationen finden Sie in der Dokumentation desRessourcenanbieters.Jeder, der Zugriff auf ein AWS CodeStar-Projekt hat, ist möglicherweise in der Lage, die AWSCodeStar-Konsole für den Zugriff auf Ressourcen zu nutzen, die außerhalb von AWS liegen, aberim Zusammenhang mit diesem Projekt stehen.Das Hinzufügen einer Teammitgliederrolle zu einem Projekt erlaubt es nicht automatisch oderverhindert, an zugehörigen AWS Cloud9-Entwicklungsumgebungen für das Projekt teilzunehmen.Wie Sie einem Teammitglied die Teilnahme an einer gemeinsamen Umgebung ermöglichenoder untersagen, erfahren Sie unter Freigeben einer AWS Cloud9-Umgebung für ein Projekt-Teammitglied (p. 60).

Sie können auch Benutzern Berechtigungen für den Remote-Zugriff auf alle Amazon EC2-Linux-Instancesim Zusammenhang mit dem Projekt gewähren. Nachdem Sie diese Berechtigung gewährt haben, mussder Benutzer einen öffentlichen SSH-Schlüssel hochladen, der mit seinem AWS CodeStar-Benutzerprofilfür alle Team-Projekte verbunden wird. Um Linux-Instances erfolgreich verbinden zu können, muss derBenutzer SSH konfiguriert und den privaten Schlüssel auf dem lokalen Computer verfügbar haben.

Themen• Teamberechtigungen verwalten (Konsole) (p. 101)• Teamberechtigungen verwalten (AWS CLI) (p. 102)

Teamberechtigungen verwalten (Konsole)Sie können die Rollen von Teammitgliedern in der AWS CodeStar-Konsole verwalten. Sie können auchfestlegen, ob Teammitglieder Remote-Zugriff auf die Amazon EC2-Instances für Ihr Projekt haben.

So ändern Sie die Rolle eines Teammitglieds


Wählen Sie das Projekt.2. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.3. Suchen Sie auf der Seite Team members (Teammitglieder) den Namen des Teammitglieds, und

wählen Sie anschließend Edit (Bearbeiten) aus.4. Wählen Sie unter Role (Rolle) die AWS CodeStar-Rolle (Eigentümer, Beitragender oder Betrachter),

die Sie diesem Benutzer gewähren möchten.

Weitere Informationen zu AWS CodeStar-Rollen und dazu gehörenden Berechtigungen finden Sieunter Arbeiten mit AWS CodeStar-Teams (p. 95).

Wählen Sie Save aus.

So gewähren Sie einem Teammitglied remote-Zugriffsberechtigungen zu Amazon EC2-Instances


101



AWS CodeStar BenutzerhandbuchTeamberechtigungen verwalten (AWS CLI)

Wählen Sie das Projekt.2. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.3. Suchen Sie auf der Seite Project team (Projektteam) den Namen des Teammitglieds, und wählen Sie

anschließend Edit (Bearbeiten) aus.4. Markieren Sie Allow SSH access to project instances (SSH-Zugriff auf Projektinstanzen erlauben) und

dann Save (Speichern).5. (Optional) Benachrichtigen Sie die Teammitglieder, dass sie einen öffentlichen SSH-Schlüssel für ihre

AWS CodeStar-Benutzer hochladen sollen, falls dies noch nicht geschehen ist. Weitere Informationenfinden Sie unter Hinzufügen eines öffentlichen Schlüssels zu Ihrem AWS CodeStar-Benutzerprofil (p. 108).

Teamberechtigungen verwalten (AWS CLI)Sie können mit der AWS CLI die einem Teammitglieder zugewiesene Projektrolle verwalten. Sie können diegleichen AWS CLI-Befehle verwenden, um festzulegen, ob das Teammitglied remote-Zugriff auf zu IhremProjekt gehörende Amazon EC2-Instances hat.

So verwalten Sie die Berechtigung für ein Teammitglied

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den Befehl update-team-member mit den Parametern --project-id, -user-arn und

--project-role aus. Sie können auch angeben, ob der Benutzer Remote-Zugriff auf Projekt-Instances hat, indem Sie den Parameter --remote-access-allowed oder --no-remote-access-allowed verwenden. Zum Beispiel: So aktualisieren Sie die Projektrolle eines IAM-Benutzers namens John_Doe und ändern dessen Berechtigungen auf Betrachter ohne Remote-Zugriffauf Projekt-Amazon EC2-Instances:

aws codestar update-team-member --project-id my-first-projec --user-arn arn:aws:iam:111111111111:user/John_Doe --project-role Viewer --no-remote-access-allowed


{ "projectRole":"Viewer", "remoteAccessAllowed":false, "userArn":"arn:aws:iam::111111111111:user/John_Doe"}

Entfernen von Teammitgliedern aus einem AWSCodeStar-Projekt

Nach dem Entfernen eines Benutzers aus einem AWS CodeStar-Projekt wird dieser weiterhin imCommit-Verlauf für das Projekt-Repository angezeigt. Er verfügt jedoch nicht mehr über Zugriff auf dasCodeCommit-Repository oder andere Projektressourcen, wie zum Beispiel die Projekt-Pipeline. (DieAusnahme zu dieser Regel ist ein IAM-Benutzer, für den andere Richtlinien gelten, die Zugriff auf dieseRessourcen gewähren.) Der Benutzer hat keinen Zugriff auf das Projekt-Dashboard und das Projekterscheint nicht länger in der Liste der Projekte, die dem Benutzer auf dem AWS CodeStar-Dashboardangezeigt werden. Sie können Teammitglieder mithilfe der AWS CodeStar-Konsole oder der AWS CLI ausIhrem Projektteam entfernen.

102

AWS CodeStar BenutzerhandbuchEntfernen von Teammitgliedern (Konsole)

Important

Auch wenn durch das Entfernen eines Teammitglieds aus einem Projekt der Remote-Zugriffauf Amazon EC2-Projekt-Instances verweigert wird, werden keine aktiven SSH-Sitzungen desBenutzers geschlossen.Das Entfernen eines Teammitglieds wirkt sich nicht auf den Zugriff dieses Teammitglieds aufRessourcen außerhalb von AWS aus (z. B. ein GitHub-Repository oder Elemente in AtlassianJIRA). Diese Zugriffsberechtigungen werden vom Anbieter der Ressource kontrolliert, nicht vonAWS CodeStar. Weitere Informationen finden Sie in der Dokumentation des Ressourcenanbieters.Das Entfernen eines Teammitglieds aus einem Projekt löscht nicht automatisch die zugehörigenAWS Cloud9-Entwicklungsumgebungen dieses Teammitglieds oder verhindert die Teilnahmedieses Mitglieds an verwandten AWS Cloud9-Entwicklungsumgebungen, zu denen es eingeladenwurde. Informationen zum Löschen einer Entwicklungsumgebung finden Sie unter Löschen einerAWS Cloud9-Umgebung von einem Projekt (p. 61). Wie Sie einem Teammitglied die Teilnahmean einer gemeinsamen Umgebung untersagen, erfahren Sie unter Freigeben einer AWS Cloud9-Umgebung für ein Projekt-Teammitglied (p. 60).

Um ein Teammitglied aus einem Projekt zu entfernen, müssen Sie über die AWS CodeStar-Eigentümerrollefür dieses Projekt verfügen oder die Richtlinie AWSCodeStarFullAccess muss auf Ihr Konto angewendetwerden.

Themen• Entfernen von Teammitgliedern (Konsole) (p. 103)• Entfernen von Teammitgliedern (AWS CLI) (p. 103)

Entfernen von Teammitgliedern (Konsole)Sie können Teammitglieder mithilfe der AWS CodeStar-Konsole aus Ihrem Projektteam entfernen.

So entfernen Sie ein Teammitglied aus einem Projekt


Wählen Sie das Projekt.2. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.3. Suchen Sie auf der Seite Team members (Teammitglieder) das Teammitglied, das Sie entfernen

möchten, und wählen Sie anschließend Remove (Entfernen) aus.

Entfernen von Teammitgliedern (AWS CLI)Sie können Teammitglieder mithilfe der AWS CLI aus Ihrem Projektteam entfernen.

So entfernen Sie ein Teammitglied

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den Befehl disassociate-team-member mit den Parametern --project-id und -user-

arn aus. Beispiel:

aws codestar disassociate-team-member --project-id my-first-projec --user-arn arn:aws:iam:111111111111:user/John_Doe


{

103


AWS CodeStar BenutzerhandbuchEntfernen von Teammitgliedern (AWS CLI)

"projectId": "my-first-projec", "userArn": "arn:aws:iam::111111111111:user/John_Doe"}

104

AWS CodeStar BenutzerhandbuchVerwalten von Anzeigeinformationen

Arbeiten mit Ihrem AWS CodeStar-Benutzerprofil

Ihr AWS CodeStar-Benutzerprofil ist mit Ihrem IAM-Benutzer verknüpft. Dieses Profil enthält einenAnzeigenamen und eine E-Mail-Adresse, die in allen AWS CodeStar Projekten verwendet werden, denenSie angehören. Sie können einen öffentlichen SSH-Schlüssel hochladen, der mit Ihrem Profil verknüpftwerden soll. Dieser öffentliche Schlüssel ist Teil des Schlüsselpaars aus öffentlichem und privatem SSH-Schlüssel, das Sie beim Herstellen einer Verbindung mit Amazon EC2-Instances verwenden, die mit AWSCodeStar-Projekten verknüpft sind, denen Sie angehören.

Note

Die Informationen in diesen Themen gelten nur für Ihr AWS CodeStar-Benutzerprofil. Wenn IhrProjekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oderElemente in Atlassian JIRA), können diese Ressourcenanbieter ihre eigenen Benutzerprofileverwenden, die unterschiedliche Einstellungen haben können. Weitere Informationen finden Sie inder Dokumentation des Ressourcenanbieters.

Themen• Verwalten von Anzeigeinformationen für Ihr AWS CodeStar-Benutzerprofil (p. 105)• Hinzufügen eines öffentlichen Schlüssels zu Ihrem AWS CodeStar-Benutzerprofil (p. 108)

Verwalten von Anzeigeinformationen für Ihr AWSCodeStar-Benutzerprofil

Sie können die AWS CodeStar-Konsole oder AWS CLI verwenden, um den Anzeigenamen und die E-Mail-Adresse in Ihrem Benutzerprofil zu ändern. Ein Benutzerprofil ist nicht projektspezifisch. Es ist mit IhremIAM-Benutzer verbunden und wird auf die AWS CodeStar-Projekte angewendet, zu denen Sie in einerAWS-Region gehören. Wenn Sie Projekten in mehr als einer AWS-Region angehören, verfügen Sie überseparate Benutzerprofile.

Sie können nur Ihr eigenes Benutzerprofil in der AWS CodeStar-Konsole verwalten. Wenn Sie über dieRichtlinie AWSCodeStarFullAccess verfügen, können Sie andere Profile mithilfe der AWS CLI anzeigenund verwalten.

Note

Die Informationen in diesem Thema gelten nur für Ihr AWS CodeStar-Benutzerprofil. Wenn IhrProjekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oderElemente in Atlassian JIRA), können diese Ressourcenanbieter ihre eigenen Benutzerprofileverwenden, die unterschiedliche Einstellungen haben können. Weitere Informationen finden Sie inder Dokumentation des Ressourcenanbieters.

Themen• Verwalten Ihres Benutzerprofils (Konsole) (p. 106)• Benutzerprofile verwalten (AWS CLI) (p. 106)

105

AWS CodeStar BenutzerhandbuchVerwalten Ihres Benutzerprofils (Konsole)

Verwalten Ihres Benutzerprofils (Konsole)Sie können Ihr Benutzerprofil in der AWS CodeStar-Konsole verwalten, indem Sie zu einem Projektnavigieren, in dem Sie Teammitglied sind, und Ihre Profilinformationen ändern. Da Benutzerprofilebenutzerspezifisch und nicht projektspezifisch sind, werden die Änderungen an Ihrem Benutzerprofil injedem Projekt in einer AWS-Region angezeigt, in dem Sie Teammitglied sind.

Important

Um die Anzeigeinformationen für einen Benutzer in der Konsole zu ändern, müssen Sie als dieserIAM-Benutzer angemeldet sein. Kein anderer Benutzer kann Ihre Anzeigeinformationen ändern –auch nicht, wenn er über die AWS CodeStar-Eigentümerrolle für ein Projekt verfügt oder wenn dieAWSCodeStarFullAccess-Richtlinie angewendet wird.

So ändern Sie Ihre Anzeigeinformationen in allen Projekten in einer AWS-Region


Wählen Sie ein Projekt, in dem Sie ein Teammitglied sind.2. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.3. Suchen Sie auf der Seite Team members (Teammitglieder) den Namen Ihres IAM-Benutzers (des

Teammitglieds, das Ihren IAM-Namen in Klammern und [You] in eckigen Klammern neben demAnzeigenamen hat), und wählen Sie dann Edit (Bearbeiten).

4. Bearbeiten Sie den Anzeigenamen, die E-Mail-Adresse oder beides und klicken Sie dann auf Save(Speichern).

Note

Es sind ein Anzeigename und eine E-Mail-Adresse erforderlich. Weitere Informationen findenSie unter Einschränkungen in AWS CodeStar (p. 145).

Benutzerprofile verwalten (AWS CLI)Sie können die AWS CLI verwenden, um Ihr Benutzerprofil in AWS CodeStar zu erstellen und zu verwalten.Sie können die AWS CLI auch verwenden, um Ihre Benutzerprofilinformationen und alle Benutzerprofileanzuzeigen, die für Ihr AWS-Konto in einer AWS-Region konfiguriert sind.

Stellen Sie sicher, dass Ihr AWS-Profil für die Region, in der Sie Benutzerprofile erstellen, verwalten oderanzeigen möchten, konfiguriert ist.

So erstellen Sie ein Benutzerprofil

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den Befehl create-user-profile mit den Parametern user-arn, display-name und

email-address aus. Beispiel:

aws codestar create-user-profile --user-arn arn:aws:iam:111111111111:user/John_Stiles --display-name "John Stiles" --email-address "[email protected]"


{ "createdTimestamp":1.491439687681E9," displayName":"John Stiles",

106


AWS CodeStar BenutzerhandbuchBenutzerprofile verwalten (AWS CLI)

"emailAddress":"[email protected]", "lastModifiedTimestamp":1.491439687681E9, "userArn":"arn:aws:iam::111111111111:user/Jane_Doe"}

So zeigen Sie Ihre Anzeigeinformationen an

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den describe-user-profile-Befehl mit dem Parameter user-arn aus. Beispiel:

aws codestar describe-user-profile --user-arn arn:aws:iam:111111111111:user/Mary_Major


{ "createdTimestamp":1.490634364532E9, "displayName":"Mary Major", "emailAddress":"[email protected]", "lastModifiedTimestamp":1.491001935261E9, "sshPublicKey":"EXAMPLE=", "userArn":"arn:aws:iam::111111111111:user/Mary_Major"}

So ändern Sie Ihre Anzeigeinformationen

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den Befehl update-user-profile aus, einschließlich des Parameters user-arn und der

Profilparameter, die Sie ändern möchten, wie beispielsweise die Parameter display-name oderemail-address. Wenn beispielsweise eine Benutzerin mit dem Anzeigenamen Jane Doe ihrenAnzeigenamen in Jane Mary Doe ändern möchte:

aws codestar update-user-profile --user-arn arn:aws:iam:111111111111:user/Jane_Doe --display-name "Jane Mary Doe"


{ "createdTimestamp":1.491439687681E9, "displayName":"Jane Mary Doe", "emailAddress":"[email protected]", "lastModifiedTimestamp":1.491442730598E9, "sshPublicKey":"EXAMPLE1", "userArn":"arn:aws:iam::111111111111:user/Jane_Doe"}

So listen Sie alle Benutzerprofile in einer AWS-Region in Ihrem AWS-Konto auf

1. Öffnen Sie ein Terminal-Fenster oder eine Eingabeaufforderung.2. Führen Sie den Befehl aws codestar list-user-profiles aus. Beispiel:

aws codestar list-user-profiles


107

AWS CodeStar BenutzerhandbuchHinzufügen eines öffentlichen

Schlüssels zu Ihrem Benutzerprofil

{ "userProfiles":[ { "displayName":"Jane Doe", "emailAddress":"[email protected]", "sshPublicKey":"EXAMPLE1", "userArn":"arn:aws:iam::111111111111:user/Jane_Doe" }, { "displayName":"John Doe", "emailAddress":"[email protected]", "sshPublicKey":"EXAMPLE2", "userArn":"arn:aws:iam::111111111111:user/John_Doe" }, { "displayName":"Mary Major", "emailAddress":"[email protected]", "sshPublicKey":"EXAMPLE=", "userArn":"arn:aws:iam::111111111111:user/Mary_Major" }, { "displayName":"John Stiles", "emailAddress":"[email protected]", "sshPublicKey":"", "userArn":"arn:aws:iam::111111111111:user/John_Stiles" } ]}

Hinzufügen eines öffentlichen Schlüssels zu IhremAWS CodeStar-Benutzerprofil

Sie können einen öffentlichen SSH-Schlüssel als Teil des Paars aus öffentlichem und privatem Schlüssel,das Sie erstellen und verwalten, hochladen. Mit diesem Paar aus öffentlichem und privatem SSH-Schlüssen greifen Sie auf Amazon EC2-Instances mit Linux zu. Wenn ein Projekt-Eigentümer Ihnen dieRemote-Zugriffsberechtigung gewährt hat, können Sie nur auf die Instances zugreifen, die mit dem Projektverbunden sind. Sie können mithilfe der AWS CodeStar-Konsole oder AWS CLI auch Ihren öffentlichenSchlüssel verwalten.

Important

Ein AWS CodeStar-Projekteigner kann Projekteignern, Beitragenden und Zuschauern SSH-Zugriff auf Amazon EC2-Instances für das Projekt gewähren, aber nur die Person (Eigentümer,Beitragender oder Betrachter) kann den SSH-Schlüssel festlegen. Zu diesem Zweck muss derBenutzer als einzelner Eigentümer, Beitragender oder Betrachter angemeldet sein.AWS CodeStar verwaltet keine SSH-Schlüssel für AWS Cloud9-Umgebungen.

Themen• So verwalten Sie Ihren öffentlichen Schlüssel (Konsole) (p. 109)• Verwalten Ihres öffentlichen Schlüssels (AWS CLI) (p. 110)• Herstellen einer Verbindung zur Amazon EC2-Instance mit Ihrem privaten Schlüssel (p. 110)

108

AWS CodeStar BenutzerhandbuchSo verwalten Sie Ihren öffentlichen Schlüssel (Konsole)

So verwalten Sie Ihren öffentlichen Schlüssel(Konsole)Obwohl Sie in der Konsole kein Paar aus öffentlichem und privatem Schlüssel erstellen können, können Siedies lokal tun und das Paar dann als Teil Ihres Benutzerprofils über die AWS CodeStar-Konsole hinzufügenund verwalten.

So verwalten Sie Ihren öffentlichen SSH-Schlüssel

1. Führen Sie von einem Terminal oder einem Bash Emulator-Fenster aus den Befehl ssh-keygen aus,um auf Ihrem lokalen Computer ein Paar aus öffentlichem und privatem SSH-Schlüssel zu generieren.Sie können einen Schlüssel in einem beliebigen für Amazon EC2 zulässigen Format generieren.Informationen zu den zulässigen Formaten finden Sie unter Importieren Ihres eigenen öffentlichenSchlüssels in Amazon EC2. Generieren Sie idealerweise einen SSH-2-RSA-Schlüssel im OpenSSH-Format mit 2048 Bit. Der öffentliche Schlüssel wird in einer Datei mit der Erweiterung .pub gespeichert.


Wählen Sie ein Projekt, in dem Sie ein Teammitglied sind.3. Wählen Sie in der Navigationsleiste für das Projekt die Option Team aus.4. Suchen Sie auf der Seite Team members (Teammitglieder) den Namen Ihres IAM-Benutzers

(des Teammitglieds, das Ihren IAM-Namen in Klammern und [You] in eckigen Klammern nebendem Anzeigenamen hat), und wählen Sie dann Add Public SSH key (Öffentlichen SSH-Schlüsselhinzufügen).

5. Fügen Sie unter Manage your public SSH key (Ihren öffentlichen SSH-Schlüssel verwalten) denöffentlichen Schlüssel ein, und wählen Sie dann Save (Speichern).

Note

Sie können Ihren öffentlichen Schlüssel ändern, indem Sie den alten Schlüssel in diesem Feldlöschen und einen neuen einfügen. Sie können einen öffentlichen Schlüssel löschen, indemSie den Inhalt dieses Feldes löschen und dann Save (Speichern) auswählen.

Wenn Sie einen öffentlichen Schlüssel ändern oder löschen, ändern Sie Ihr Benutzerprofil. Dies istkeine nur für ein Projekt geltende Änderung. Da Ihre Schlüssel Ihrem Profil zugeordnet ist, ändert ersich in allen Projekten, für die Ihnen Remote-Zugriff gewährt wurde (oder wird dort gelöscht).

109

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html#how-to-generate-your-own-key-and-import-it-to-aws



AWS CodeStar BenutzerhandbuchVerwalten Ihres öffentlichen Schlüssels (AWS CLI)

Wenn Sie Ihren öffentlichen Schlüssel löschen, verlieren Sie den Zugriff auf Amazon EC2-Instancesmit Linux in allen Projekten, für die Ihnen Remote-Zugriff gewährt wurde. Offene SSH-Sitzungen,die diesen Schlüssel verwenden, werden jedoch nicht geschlossen. Stellen Sie sicher, dass Sie alleoffenen Sitzungen schließen.

Verwalten Ihres öffentlichen Schlüssels (AWS CLI)Sie können Ihren öffentlichen SSH-Schlüssel als Teil Ihres Benutzerprofils mithilfe von AWS CLI verwalten.

So verwalten Sie Ihren öffentlichen Schlüssel

1. Führen Sie von einem Terminal oder einem Bash Emulator-Fenster aus den Befehl ssh-keygen aus,um auf Ihrem lokalen Computer ein Paar aus öffentlichem und privatem SSH-Schlüssel zu generieren.Sie können einen Schlüssel in einem beliebigen für Amazon EC2 zulässigen Format generieren.Informationen zu den zulässigen Formaten finden Sie unter Importieren Ihres eigenen öffentlichenSchlüssels in Amazon EC2. Generieren Sie idealerweise einen SSH-2-RSA-Schlüssel im OpenSSH-Format mit 2048 Bit. Der öffentliche Schlüssel wird in einer Datei mit der Erweiterung .pub gespeichert.

2. Führen Sie den Befehl update-user-profile mit dem Parameter --ssh-public-key aus, um Ihrenöffentlichen SSH-Schlüssel in Ihrem AWS CodeStar-Benutzerprofil hinzuzufügen oder zu ändern.Beispiel:

aws codestar update-user-profile --user-arn arn:aws:iam:111111111111:user/Jane_Doe --ssh-key-id EXAMPLE1


{ "createdTimestamp":1.491439687681E9, "displayName":"Jane Doe", "emailAddress":"[email protected]", "lastModifiedTimestamp":1.491442730598E9, "sshPublicKey":"EXAMPLE1", "userArn":"arn:aws:iam::111111111111:user/Jane_Doe"}

Herstellen einer Verbindung zur Amazon EC2-Instancemit Ihrem privaten SchlüsselStellen Sie sicher, dass Sie bereits ein Amazon EC2-Schlüsselpaar erstellt haben. Fügen Sie Ihrenöffentlichen Schlüssel zu Ihrem Benutzerprofil in AWS CodeStar hinzu. Informationen zum Erstellen einesSchlüsselpaars finden Sie unter Schritt 4:Erstellen eines Amazon EC2-Schlüsselpaars für AWS CodeStar-Projekte (p. 5). Zum Hinzufügen des öffentlichen Schlüssels zu Ihrem Benutzerprofil siehe die Anleitungoben in diesem Thema.

So verbinden Sie sich mit einer Amazon EC2-Linux-Instance mit Ihrem privaten Schlüssel

1. Wählen Sie bei geöffnetem Projekt in der AWS CodeStar-Konsole im Navigationsfenster Project(Projekt).

2. Wählen Sie unter Project Resources für die Zeile, in der Type Amazon EC2 ist und der Name mitinstance beginnt, den Link ARN.

3. Wählen Sie in der Amazon EC2-Konsole Connect (Verbinden) aus.4. Befolgen Sie die Anweisungen im Dialogfeld Connect To Your Instance (Mit Ihrer Instance verbinden).

110



AWS CodeStar BenutzerhandbuchHerstellen einer Verbindung zur Amazon

EC2-Instance mit Ihrem privaten Schlüssel

Verwenden Sie als Benutzername ubuntu für auf der Projektvorlage ASP.NET Core basierendeProjekte, weil diese Instances Ubuntu verwenden. Verwenden Sie für alle anderen Projekte ec2-user als Benutzername, da diese Instances Amazon Linux verwenden. Wenn Sie den falschenBenutzernamen verwenden, können Sie keine Verbindung mit der Instance herstellen.

Weitere Informationen finden Sie in den folgenden Ressourcen im Amazon EC2-Benutzerhandbuch fürLinux-Instances.

• Herstellen einer Verbindung mit Ihrer Linux-Instance per SSH• Herstellung einer Verbindung zu Ihrer Linux-Instance von Windows mit PuTTY• Herstellen einer Verbindung mit Ihrer Linux-Instance mit MindTerm

111

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/AccessingInstancesLinux.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/putty.html

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/mindterm.html


AWS CodeStar-Zugriffsberechtigungen – Referenz

Sie können AWS CodeStar als IAM-Benutzer, verbundener Benutzer, Root-Benutzer oder übernommeneRolle verwenden. Alle Benutzer mit den entsprechenden Berechtigungen können Projektberechtigungenfür ihre AWS-Ressourcen verwalten, aber AWS CodeStar verwaltet Projektberechtigungen automatischfür IAM-Benutzer. IAM-Richtlinien und Rollen erteilen diesem Benutzer auf der Grundlage der ProjektrolleBerechtigungen und Zugriff. Sie können die IAM-Konsole verwenden, um weitere Richtlinien zu erstellen,die einem IAM-Benutzer AWS CodeStar- und andere Berechtigungen erteilen.

Sie können beispielsweise einem Benutzer erlauben, ein AWS CodeStar-Projekt anzuzeigen, jedoch nichtzu ändern. In diesem Fall fügen Sie den IAM-Benutzer einem AWS CodeStar-Projekt mit der Betrachter-Rolle hinzu. Jedes AWS CodeStar Projekt verfügt über eine Reihe von Richtlinien, mit deren Hilfe Sie denZugriff auf das Projekt steuern können. Außerdem können Sie steuern, welche Benutzer Zugriff auf AWSCodeStar haben.

In den Einrichten von AWS CodeStar (p. 3)-Anweisungen haben Sie Ihrem IAM-Benutzer eine Richtlinie mitdem Namen AWSCodeStarFullAccess angefügt. Ein Beispiel für diese Richtlinienanweisung finden Sieunter AWSCodeStarFullAccess (p. 121).

Diese Richtlinienanweisung erlaubt dem Benutzer, alle verfügbaren Aktionen in AWS CodeStar mit allenverfügbaren AWS CodeStar-Ressourcen durchzuführen, die mit dem AWS-Konto verknüpft sind. Dazuzählen das Erstellen und Löschen von Projekten. Sie möchten wahrscheinlich nicht allen Benutzern soumfassenden Zugriff gewähren. Stattdessen können Sie Berechtigungen auf Projektebene mit Hilfe vonProjektrollen hinzufügen, die von AWS CodeStar verwaltet werden. Die Rollen gewähren bestimmteZugriffsebenen auf AWS CodeStar-Projekte und werden wie folgt benannt:

• Eigentümer• Beitragender• Betrachter

Der AWS CodeStar-Zugriff wird für IAM-Benutzer und verbundene Benutzer unterschiedlich behandelt. NurIAM-Benutzer können zu Teams hinzugefügt werden. Um IAM-Benutzern Berechtigungen für Projekte zuerteilen, fügen Sie den Benutzer zum Projektteam hinzu und weisen ihm eine Rolle zu. Um verbundenenBenutzern Berechtigungen für Projekte zu erteilen, fügen Sie die verwaltete Richtlinie der AWS CodeStar-Projektrolle manuell an die Rolle des verbundenen Benutzers an. Diese Tabelle fasst die verfügbarenWerkzeuge für jede Zugriffsart zusammen.

Berechtigungsfunktion IAM-Benutzer

VerbundenerBenutzer

Stammbenutzer

SSH-Schlüsselverwaltung für den Fernzugriff für Amazon EC2-und Elastic Beanstalk-Projekte

AWS CodeCommitSSH-Zugriff

IAM-Benutzerberechtigungen, die von AWS CodeStar verwaltetwerden.

Manuell verwaltete Projektberechtigungen

112

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html

AWS CodeStar BenutzerhandbuchAWS CodeStar-Projektebenenrichtlinien

und -berechtigungen

Berechtigungsfunktion IAM-Benutzer

VerbundenerBenutzer

Stammbenutzer

Benutzer können als Teammitglieder dem Projekt hinzugefügtwerden

Themen• AWS CodeStar-Projektebenenrichtlinien und -berechtigungen (p. 113)• Richtlinie und Berechtigungen für die AWS CodeStar Service-Rolle (p. 117)• Aktions- und Ressourcensyntax (p. 118)• Beispiele für AWS CodeStar-Richtlinien (p. 121)• IAM-Benutzerzugriff auf AWS CodeStar (p. 137)• Zugriff für verbundene Benutzer auf AWS CodeStar (p. 138)

AWS CodeStar-Projektebenenrichtlinien und -berechtigungen

Wenn Sie ein Projekt erstellen, erstellt AWS CodeStar die IAM-Rollen und -Richtlinien, die Sie benötigen,um Ihre Projektressourcen zu verwalten. Die Richtlinien fallen in drei Kategorien:

• IAM-Richtlinien für Projektteammitglieder• IAM-Richtlinien für Auftragnehmerrollen• IAM-Richtlinien für eine Laufzeitausführungsrolle

IAM-Richtlinien für TeammitgliederWenn Sie ein Projekt erstellen, erstellt AWS CodeStar drei von Kunden verwaltete Richtlinien für Zugriff aufdas Projekt durch Eigentümer, Beitragende und Betrachter. Alle AWS CodeStar-Projekte enthalten IAM-Richtlinien für diese drei Zugriffsebenen. Diese Zugriffsebenen gelten spezifisch für ein Projekt und sinddurch eine von IAM verwaltete Richtlinie mit einem Standardnamen definiert, wobei project-id die IDdes AWS CodeStar-Projekts ist (z. B. my-first-projec):

• CodeStar_project-id_Owner

• CodeStar_project-id_Contributor

• CodeStar_project-id_Viewer

Important

Diese Richtlinien können von AWS CodeStar geändert werden. Sie sollten nicht manuellbearbeitet werden. Wenn Sie Berechtigungen hinzufügen oder ändern möchten, fügen Sie demIAM-Benutzer zusätzliche Richtlinien an.

Sobald Sie Teammitglieder (IAM-Benutzer) zum Projekt hinzufügen und ihre Zugriffsebenen auswählen,wird die entsprechende Richtlinie dem IAM-Benutzer angefügt, wodurch dem Benutzer die entsprechendenBerechtigungen für das Handeln mit den Projektressourcen erteilt werden. In den meisten Fällen müssenSie Richtlinien oder Berechtigungen nicht direkt anfügen oder in IAM verwalten. Das manuelle Anfügeneiner AWS CodeStar-Zugriffsebenenrichtlinie an einen IAM-Benutzer wird nicht empfohlen. Wenn dies alsErgänzung einer AWS CodeStar-Zugriffsebenenrichtlinie unbedingt notwendig ist, können Sie Ihre eigenen

113

AWS CodeStar BenutzerhandbuchIAM-Richtlinien für Auftragnehmerrollen

verwalteten oder eingebundenen Richtlinien erstellen, um Ihre eigene Berechtigungsstufe auf einen IAM-Benutzer anzuwenden.

Die Richtlinien sind eng auf Projektressourcen und spezifische Aktionen ausgerichtet. Sobald neueRessourcen zum Infrastrukturstapel hinzugefügt werden, versucht AWS CodeStar, die Richtlinien derTeammitglieder zu aktualisieren, um Berechtigungen für den Zugriff auf die neue Ressource aufzunehmen,wenn es sich um einen der unterstützten Ressourcentypen handelt.

Note

Die Richtlinien für Zugriffsebenen in einem AWS CodeStar-Projekt gelten nur für das jeweiligeProjekt. Dadurch können Sie sicherstellen, dass Benutzer nur die AWS CodeStar-Projekte sehenund damit interagieren können, für die sie Berechtigungen besitzen, sowie im Rahmen ihrer Rolle.Nur für Benutzer, die AWS CodeStar-Projekte erstellen, sollte eine Richtlinie angewendet werden,die unabhängig vom jeweiligen Projekt Zugriff auf alle AWS CodeStar-Ressourcen gewährt.

Alle AWS CodeStar-Zugriffsebenenrichtlinien variieren je nach den AWS-Ressourcen, die zum Projektgehören, denen die Zugriffsebenen zugeordnet sind. Im Gegensatz zu anderen AWS-Services werdendiese Richtlinien angepasst, wenn das Projekt erstellt und im Zuge der Änderung von Projektressourcenaktualisiert wird. Aus diesem Grund gibt es keine kanonischen Eigentümer-, Beitragende- oder Betrachter-verwaltete Richtlinien.

AWS CodeStar-Richtlinie für die Eigentümer-RolleDie von CodeStar_project-id_Owner-kundenverwaltete Richtlinie ermöglicht es einem Benutzer, alleAktionen im AWS CodeStar-Projekt ohne Einschränkungen durchzuführen. Dies ist die einzige Richtlinie,mit der ein Benutzer Teammitglieder hinzufügen oder entfernen kann. Der Inhalt der Richtlinie variiert jenach den mit dem Projekt verbundenen Ressourcen. Ein Beispiel finden Sie unter AWS CodeStar-Richtliniefür die Eigentümer-Rolle (p. 124).

Ein IAM-Benutzer mit dieser Richtlinie kann alle AWS CodeStar-Aktionen im Projekt durchführen, andersals ein IAM-Benutzer mit der Richtlinie AWSCodeStarFullAccess kann er jedoch keine neuen Projekteerstellen. Die codestar:*-Berechtigung ist auf eine bestimmte Ressource begrenzt (das AWS CodeStar-Projekt, das mit der jeweiligen Projekt-ID verbunden ist).

Richtlinie für die AWS CodeStar-Beitragender-RolleDie CodeStar_project-id_Contributor-kundenverwaltete Richtlinie ermöglicht einem Benutzer, zueinem Projekt beizutragen und das Projekt-Dashboard zu ändern; er kann jedoch keine Teammitgliederhinzufügen oder entfernen. Der Inhalt der Richtlinie variiert je nach den mit dem Projekt verbundenenRessourcen. Ein Beispiel finden Sie unter Richtlinie für die AWS CodeStar-Beitragender-Rolle (p. 125).

AWS CodeStar-Richtlinie für die BetrachterrolleDie CodeStar_project-id_Viewer-kundenverwaltete Richtlinie ermöglicht einem Benutzer, einProjekt in AWS CodeStar anzuzeigen, jedoch nicht dessen Ressourcen zu ändern oder Teammitgliederhinzuzufügen oder zu entfernen. Der Inhalt der Richtlinie variiert je nach den mit dem Projekt verbundenenRessourcen. Ein Beispiel finden Sie unter AWS CodeStar-Richtlinie für die Betrachterrolle (p. 126).

IAM-Richtlinien für AuftragnehmerrollenWenn Sie Ihr AWS CodeStar-Projekt nach 6. Dezember 2018 PDT erstellen, erstellt AWS CodeStarzwei Auftragnehmerrollen, CodeStar-project-id-ToolChain und CodeStar-project-id-CloudFormation. Eine Auftragnehmerrolle ist eine projektspezifische IAM-Rolle, die AWS CodeStarerstellt, um sie an einen Service zu übergeben. Sie erteilt Berechtigungen, damit der Service Ressourcenerstellen und Aktionen im Rahmen Ihres AWS CodeStar-Projekts ausführen kann. Die Toolchain-Auftragnehmerrolle hat eine Vertrauensstellung mit Toolchainservices wie CodeBuild, CodeDeploy und

114

AWS CodeStar BenutzerhandbuchIAM-Richtlinie für die Ausführungsrolle

CodePipeline etabliert. Den Mitgliedern des Projektteams (Eigentümern und Beitragenden) wird Zugrifferteilt, um die Auftragnehmerrolle an vertrauenswürdige nachgelagerte Services weiterzugeben. EinBeispiel für die eingebundene Richtlinienanweisung für diese Rolle finden Sie unter Richtlinie für Toolchain-Auftragnehmerrolle (nach 6. Dezember 2018 PDT) (p. 132).

Die CloudFormation-Auftragnehmerrolle enthält Berechtigungen für von AWS CloudFormation unterstützteRessourcen, sowie Berechtigungen zum Erstellen von IAM-Benutzern, -Rollen und -Richtlinien in IhremAnwendungsstack. Sie hat auch eine Vertrauensbeziehung mit AWS CloudFormation etabliert. Umdie Risiken einer Eskalation von Berechtigungen und destruktiver Aktionen zu minimieren, enthält dieRollenrichtlinie AWS CloudFormation eine Bedingung, die die projektspezifische Berechtigungsgrenzefür jede IAM-Einheit (Benutzer oder Rolle) erfordert, die im Infrastrukturstapel erstellt wurde. Ein Beispielfür die eingebundene Richtlinienanweisung für diese Rolle finden Sie unter AWS CloudFormation-Auftragnehmerrollen-Richtlinie (p. 128).

Für AWS CodeStar-Projekte die vor 6. Dezember 2018 PDT erstellt wurden, erstellt AWS CodeStarindividuelle Workerrollen für Toolchain-Ressourcen wie CodePipeline, CodeBuild und CloudWatch-Ereignisse, und erstellt auch eine Workerrolle für AWS CloudFormation, die eine begrenzte Anzahlvon Ressourcen unterstützt. Jede dieser Rollen verfügt über eine etablierte Vertrauensstellung mitdem entsprechenden Service. Den Mitgliedern des Projektteams (Eigentümern und Beitragenden) undeinige der anderen Auftragnehmerrollen wird Zugriff erteilt, um die Rolle an die vertrauenswürdigennachgelagerten Services weiterzugeben. Berechtigungen für die Auftragnehmerrollen sind in einereingebundenen Richtlinie definiert, die auf einen grundlegenden Satz von Aktionen beschränkt ist, diedie Rolle für eine Reihe von Projektressourcen ausführen kann. Diese Berechtigungen sind statisch.Dazu gehören Berechtigungen für Ressourcen, die bei der Erstellung in das Projekt aufgenommen, abernicht aktualisiert werden, wenn neue Ressourcen zum Projekt hinzugefügt werden. Beispiele dieserRichtlinienanweisungen finden Sie unter:

• AWS CloudFormation-Auftragnehmerrollenrichtlinie (vor 6. Dezember 2018 PDT) (p. 135)• CodePipeline-Auftragnehmerrollenrichtlinie (vor 6. Dezember 2018 PDT) (p. 134)• CodeBuild-Auftragnehmerrollenrichtlinie (vor 6. Dezember 2018 PDT) (p. 133)• CloudWatch-Ereignisse-Auftragnehmerrollenrichtlinie (vor 6. Dezember 2018 PDT) (p. 136)

IAM-Richtlinie für die AusführungsrolleFür Projekte, die nach 6. Dezember 2018 PDT erstellt werden, erstellt AWS CodeStar eine generischeAusführungsrolle für das Beispielprojekt in Ihrem Anwendungsstack. Die Rolle wird unter Verwendungder Richtlinie für Berechtigungsgrenzen auf Projektressourcen reduziert. Wenn Sie das Beispielprojekterweitern, können Sie zusätzliche IAM-Rollen erstellen, und die AWS CloudFormation-Rollenrichtlinieverlangt, dass diese Rollen unter Verwendung der Berechtigungsgrenze heruntergefahren werden, um eineEskalation von Berechtigungen zu vermeiden. Weitere Informationen finden Sie unter Hinzufügen einerIAM-Rolle zu einem Projekt (p. 77).

Für Lambda-Projekte, die vor dem 6. Dezember 2018 PDT erstellt wurden, erstellt AWS CodeStareine Lambda-Ausführungsrolle, der eine eingebundene Richtlinie mit Berechtigungen zum Zugriff aufdie Ressourcen im Projekt AWS SAM-Stack angefügt ist. Sobald neue Ressourcen zur SAM-Vorlagehinzugefügt werden, versucht AWS CodeStar, die Lambda-Ausführungsrollenrichtlinie zu aktualisieren,um Berechtigungen für den Zugriff auf die neue Ressource aufzunehmen, wenn es sich um einen derunterstützten Ressourcentypen handelt.

IAM-BerechtigungsgrenzeNach 6. Dezember 2018 PDT, wenn Sie ein Projekt erstellen, erstellt AWS CodeStar einekundenverwaltete Richtlinie und weist diese Richtlinie als IAM-Berechtigungsgrenze den IAM-Rollen imProjekt zu. AWS CodeStar erfordert, dass alle IAM-Entitäten, die im Anwendungs-Stack erstellt werden,eine Berechtigungsgrenze haben. Eine Berechtigungsgrenze kontrolliert die maximalen Berechtigungen,

115

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_boundaries.html

AWS CodeStar BenutzerhandbuchVorhandenen Projekten eine IAM-Berechtigungsgrenze hinzufügen

die die Rolle haben kann, weist der Rolle aber keine Berechtigungen zu. Berechtigungsrichtliniendefinieren die Berechtigungen für die Rolle. Das bedeutet, dass jeder, der die Rolle verwendet, nichtmehr als die in der Berechtigungsgrenze enthaltenen Aktionen ausführen kann, unabhängig davon,wie viele zusätzliche Berechtigungen zu einer Rolle hinzugefügt werden. Weitere Informationendarüber, wie Berechtigungsrichtlinien und Berechtigungsgrenzen ausgewertet werden, finden Sie unterAuswertungslogik für Richtlinien in der IAM-Benutzerhandbuch.

AWS CodeStar verwendet eine projektspezifische Berechtigungsgrenze, um eine Eskalationvon Berechtigungen auf Ressourcen außerhalb des Projekts zu verhindern. Die AWS CodeStar-Berechtigungsgrenze enthält ARNs für Projektressourcen. Ein Beispiel für diese Richtlinienanweisungfinden Sie unter AWS CodeStar-Berechtigungsgrenzen-Richtlinie (p. 127).

Die Transformation AWS CodeStar aktualisiert diese Richtlinie, wenn Sie über den Anwendungsstapel(template.yml) dem Projekt eine unterstützte Ressource hinzufügen oder daraus entfernen.

Vorhandenen Projekten eine IAM-Berechtigungsgrenze hinzufügenWenn Sie ein AWS CodeStar-Projekt haben, das vor dem 6. Dezember 2018 PDT erstellt wurde, solltenSie den IAM-Rollen im Projekt manuell eine Berechtigungsgrenze hinzufügen. Als bewährte Methodeempfehlen wir die Verwendung einer projektspezifischen Grenze, die dem Projekt nur Ressourcenhinzufügt, um eine Eskalation von Berechtigungen auf Ressourcen außerhalb des Projekts zu vermeiden.Befolgen Sie diese Schritte, um die von AWS CodeStar verwaltete Berechtigungsgrenze zu verwenden, diewährend der Entwicklung des Projekts aktualisiert wird.

1. Melden Sie sich an der AWS CloudFormation-Konsole an und suchen Sie die Vorlage für den Toolchain-Stack in Ihrem Projekt. Diese Vorlage hat den Namen awscodestar-project-id.

2. Wählen Sie die Vorlage aus und wählen Sie Actions (Aktionen) und danach View/Edit template inDesigner (Vorlage in Designer anzeigen/bearbeiten).

3. Suchen Sie den Abschnitt Resources und fügen Sie folgendes Snippet oben im Abschnitt ein.

PermissionsBoundaryPolicy: Description: Creating an IAM managed policy for defining the permissions boundary for an AWS CodeStar project Type: AWS::IAM::ManagedPolicy Properties: ManagedPolicyName: !Sub 'CodeStar_${ProjectId }_PermissionsBoundary' Description: 'IAM policy to define the permissions boundary for IAM entities created in an AWS CodeStar project' PolicyDocument: Version: '2012-10-17' Statement: - Sid: '1' Effect: Allow Action: ['*'] Resource: - !Sub 'arn:${AWS::Partition}:cloudformation:${AWS::Region}:${AWS::AccountId}:stack/awscodestar-${ProjectId}-*'

Möglicherweise benötigen Sie zusätzliche IAM-Berechtigungen, um den Stack von der AWSCloudFormation-Konsole aus zu aktualisieren.

4. Wenn Sie anwendungsspezifische IAM-Rollen erstellen möchten, führen Sie diesen Schritt aus.Aktualisieren Sie von der IAM-Konsole aus die eingebundene Richtlinie, die der AWS CloudFormation-Rolle angefügt ist, damit Ihr Projekt folgendes Snippet enthält. Möglicherweise benötigen Sie zusätzlicheIAM-Ressourcen, um die Richtlinie zu aktualisieren.

116

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html

AWS CodeStar BenutzerhandbuchRichtlinie und Berechtigungen fürdie AWS CodeStar Service-Rolle

{ "Action": [ "iam:PassRole" ], "Resource": "arn:aws:iam::{AccountId}:role/CodeStar-{ProjectId}*", "Effect": "Allow" }, { "Action": [ "iam:CreateServiceLinkedRole", "iam:GetRole", "iam:DeleteRole", "iam:DeleteUser" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "iam:AttachRolePolicy", "iam:AttachUserPolicy", "iam:CreateRole", "iam:CreateUser", "iam:DeleteRolePolicy", "iam:DeleteUserPolicy", "iam:DetachUserPolicy", "iam:DetachRolePolicy", "iam:PutUserPermissionsBoundary", "iam:PutRolePermissionsBoundary" ], "Resource": "*", "Condition": { "StringEquals": { "iam:PermissionsBoundary": "arn:aws:iam::{AccountId}:policy/CodeStar_{ProjectId}_PermissionsBoundary" } }, "Effect": "Allow" }

5. Übertragen Sie eine Änderung durch Ihre Projektpipeline, damit AWS CodeStar dieBerechtigungsgrenze mit entsprechenden Berechtigungen aktualisiert.

Weitere Informationen finden Sie unter Hinzufügen einer IAM-Rolle zu einem Projekt (p. 77).

Richtlinie und Berechtigungen für die AWSCodeStar Service-Rolle

AWS CodeStar verwendet eine Service-Rolle, aws-codestar-service-role, bei der Erstellung und Verwaltungder Ressourcen für Ihr Projekt. Weitere Informationen finden Sie unter Rollenbegriffe und -konzepte imIAM-Benutzerhandbuch.

Important

Sie müssen als administrativer IAM-Benutzer oder im Stammkonto angemeldet sein, um dieseService-Rolle erstellen zu können. Weitere Informationen finden Sie unter Nur für erstmaligen

117

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_terms-and-concepts.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_identity-management.html#intro-identity-first-time-access

AWS CodeStar BenutzerhandbuchAktions- und Ressourcensyntax

Zugriff: Ihre Stammbenutzer-Anmeldeinformationen und Erstellen Ihres ersten IAM Admin-Benutzers und der ersten Admin-Gruppe im IAM-Benutzerhandbuch.

Die Rolle wird für Sie erstellt, wenn Sie zum ersten Mal in AWS CodeStar ein Projekt erstellen. Die Service-Rolle fungiert für Sie für folgende Zwecke:

• Erstellen der Ressourcen, die Sie auswählen, wenn Sie ein Projekt erstellen.• Anzeige der Informationen über diese Ressourcen im AWS CodeStar Projekt-Dashboard.

Sie agiert auch für Sie bei der Verwaltung der Ressourcen für ein Projekt. Ein Beispiel für dieseRichtlinienanweisung finden Sie unter AWS CodeStar-Richtlinie für die Servicerolle (p. 122).

Aktions- und RessourcensyntaxIn den folgenden Abschnitten wird das Format für das Festlegen von Aktionen und Ressourcenbeschrieben.

Aktionen weisen dieses allgemeine Format auf:

codestar:action

action ist hierbei eine verfügbare AWS CodeStar-Operation, wie für ListProjects oderAssociateResource. Um eine Aktion zuzulassen, verwenden Sie die "Effect" : "Allow"-Klausel.Um eine Aktion explizit abzulehnen, verwenden Sie die "Effect" : "Deny"-Klausel. Standardmäßigwerden alle Aktionen abgelehnt, es sei denn, sie sind in einer anderen angefügten Richtlinie anderweitigfestgelegt.

Ressourcen weisen dieses allgemeine Format auf:

arn:aws:codestar:region:account:resource-specifier

region ist dabei eine AWS-Region (wie etwa us-east-2), account ist die AWS-Konto-ID undresource-specifier ist die Projekt-ID. Platzhalterzeichen (*) können verwendet werden, um einen Teileines Namens anzugeben.

So gibt das folgende Beispiel das AWS CodeStar-Projekt mit dem Namen my-first-projec an, das mitdem AWS-Konto 111111111111 in der AWS-Region us-east-2 angemeldet ist:

arn:aws:codestar:us-east-2:111111111111:project/my-first-projec

Das folgende Beispiel gibt alle AWS CodeStar-Projekte an, die mit dem Namen my-proj beginnen und mitdem AWS-Konto 111111111111 in der AWS-Region us-east-2 angemeldet sind:

arn:aws:codestar:us-east-2:111111111111:project/my-proj*

Themen• Bestimmen des Geltungsbereichs von Ressourcen in AWS CodeStar (p. 119)• Projekte (p. 119)• Ressourcen (p. 119)• Teams (p. 120)• Benutzer (p. 120)

118

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_identity-management.html#intro-identity-first-time-access



AWS CodeStar BenutzerhandbuchBestimmen des Geltungsbereichsvon Ressourcen in AWS CodeStar

Bestimmen des Geltungsbereichs von Ressourcen inAWS CodeStarManche der Berechtigungen in AWS CodeStar können nicht für eine Ressource gelten, sondern müssenstattdessen für alle gültig sein, ansonsten schlägt die Aktion fehl.

Für die folgende Aktion kann kein Geltungsbereich bestimmt werden. Sie muss auf *: festgelegt werden

• ListProjects

ProjekteZu den zulässigen Aktionen gehören:

• CreateProject zur Erstellung eines AWS CodeStar-Projekts.• DeleteProject zum Löschen eines AWS CodeStar-Projekts.• DescribeProject zur Beschreibung der Attribute eines AWS CodeStar-Projekts.• ListProjects zur Auflistung aller AWS CodeStar-Projekte.• UpdateProject zur Aktualisierung der Attribute eines AWS CodeStar-Projekts.

Das folgende Beispiel ermöglicht einem bestimmten IAM-Benutzer die Bearbeitung der Attribute eines AWSCodeStar-Projekts, etwa seiner Projektbeschreibung:

{ "Version": "2012-10-17", "Statement" : [ { "Effect" : "Allow", "Action" : [ "codestar:UpdateProject" ], "Resource" : "arn:aws:codestar:us-east-2:project/my-first-projec" } ]}

RessourcenZu den zulässigen Aktionen gehören:

• ListResources zur Auflistung aller Ressourcen für ein AWS CodeStar-Projekt.

Das folgende Beispiel ermöglicht einem IAM-Benutzer mit dieser Richtlinie die Auflistung der Ressourcenfür ein Projekt mit der ID my-first-projec:

{ "Version": "2012-10-17", "Statement" : [ { "Effect" : "Allow", "Action" : [ "codestar:ListResources", ],

119

AWS CodeStar BenutzerhandbuchTeams

"Resource" : "arn:aws:codestar:us-east-2:project/my-first-projec" } ]}

TeamsZu den zulässigen Aktionen gehören:

• AssociateTeamMember zum Hinzufügen eines Benutzers zu einem AWS CodeStar-Projekt.• DisassociateTeamMember zum Entfernen eines Benutzers aus einem AWS CodeStar-Projekt.• ListTeamMembers zur Auflistung aller Benutzer in einem AWS CodeStar-Projekt.• UpdateTeamMember zum Ändern der Attribute der Teammitglieder in einem AWS CodeStar-Projekt

(etwa der Projektrolle eines Benutzers).

Das folgende Beispiel ermöglicht einem IAM-Benutzer mit dieser Richtlinie das Hinzufügen vonTeammitgliedern zu einem AWS CodeStar-Projekt mit der Projekt-ID my-first-projec, gibt ihm aberausdrücklich nicht die Möglichkeit, Teammitglieder zu entfernen:

{ "Version": "2012-10-17", "Statement" : [ { "Effect" : "Allow", "Action" : [ "codestar:AssociateTeamMember", ], "Resource" : "arn:aws:codestar:us-east-2:project/my-first-projec" }, { "Effect" : "Deny", "Action" : [ "codestar:DisassociateTeamMember", ], "Resource" : "arn:aws:codestar:us-east-2:project/my-first-projec" } ] ]}

BenutzerZu den zulässigen Aktionen gehören:

• CreateUserProfile zum Erstellen eines Benutzerprofils in AWS CodeStar. Dieses Profil enthältDaten zu dem Benutzer, z. B. einen Anzeigenamen, der in allen AWS CodeStar Projekten erscheint.

• DeleteUserProfile zum Löschen des Profils eines AWS CodeStar-Benutzers.• DescribeUserProfile zum Abrufen von Informationen zu einem AWS CodeStar-Benutzerprofil.• ListUserProfiles zur Auflistung aller AWS CodeStar-Benutzerprofile für ein AWS-Konto.• UpdateUserProfile zur Aktualisierung eines AWS CodeStar-Profils für einen Benutzer.

Das folgende Beispiel ermöglicht einem IAM-Benutzer mit dieser Richtlinie die Auflistung aller AWSCodeStar-Benutzerprofile im Zusammenhang mit einem AWS-Konto:

120

AWS CodeStar BenutzerhandbuchBeispiele für AWS CodeStar-Richtlinien

{ "Version": "2012-10-17", "Statement" : [ { "Effect" : "Allow", "Action" : [ "codestar:ListUserProfiles", ], "Resource" : "*" } ]}

Beispiele für AWS CodeStar-RichtlinienAWS CodeStar erstellt mehrere Richtlinien für Sie zum Erstellen und Verwalten von Projektressourcen.Wenn Sie Ihr AWS CodeStar-Projekt anpassen möchten, kann es hilfreich sein, den Inhalt der typischenRichtlinien zu verstehen.

Themen• AWS-verwaltete Richtlinien (p. 121)• Vom Kunden verwaltete Richtlinien (p. 124)• Eingebundene Richtlinien (p. 128)

AWS-verwaltete RichtlinienAWS bietet zwei verwaltete (vordefinierte) Richtlinien für AWS CodeStar, die Servicerolle und dieAWSCodeStarFullAccess. Wenn Sie erstmals ein AWS CodeStar-Projekt erstellen, löst dies dieErstellung der AWS CodeStar Servicerollen-Richtlinie aus. Die AWSCodeStarFullAccess-Richtlinie mussan Ihren IAM-Benutzer angefügt werden, bevor Sie Ihr erstes AWS CodeStar-Projekt erstellen können.

AWSCodeStarFullAccessDie Richtlinie AWSCodeStarFullAccess erlaubt vollständigen Zugriff auf AWS CodeStar. WeitereInformationen zu dieser Richtlinie finden Sie unter AWS CodeStar-Zugriffsberechtigungen –Referenz (p. 112).

{ "Version": "2012-10-17", "Statement": [ { "Sid": "CodeStarEC2", "Effect": "Allow", "Action": [ "codestar:*", "ec2:DescribeKeyPairs", "ec2:DescribeVpcs", "ec2:DescribeSubnets" ], "Resource": "*" }, { "Sid": "CodeStarCF", "Effect": "Allow", "Action": [

121

AWS CodeStar BenutzerhandbuchAWS-verwaltete Richtlinien

"cloudformation:DescribeStack*", "cloudformation:GetTemplateSummary" ], "Resource": [ "arn:aws:cloudformation:*:*:stack/awscodestar-*" ] } ]}

AWS CodeStar-Richtlinie für die ServicerolleDie aws-codestar-service-role-Richtlinie ist an die Servicerolle angefügt, die AWS CodeStar dieAusführung von Aktionen mit anderen Services erlaubt. Weitere Informationen finden Sie unter Richtlinieund Berechtigungen für die AWS CodeStar Service-Rolle (p. 117).

{ "Version": "2012-10-17", "Statement": [ { "Sid": "ProjectStack", "Effect": "Allow", "Action": [ "cloudformation:*Stack*", "cloudformation:*ChangeSet*", "cloudformation:GetTemplate" ], "Resource": [ "arn:aws:cloudformation:*:*:stack/awscodestar-*", "arn:aws:cloudformation:*:*:stack/awseb-*", "arn:aws:cloudformation:*:*:stack/aws-cloud9-*", "arn:aws:cloudformation:*:aws:transform/CodeStar*" ] }, { "Sid": "ProjectStackTemplate", "Effect": "Allow", "Action": [ "cloudformation:GetTemplateSummary", "cloudformation:DescribeChangeSet" ], "Resource": "*" }, { "Sid": "ProjectQuickstarts", "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::awscodestar-*/*" ] }, { "Sid": "ProjectS3Buckets", "Effect": "Allow", "Action": [ "s3:*" ], "Resource": [ "arn:aws:s3:::aws-codestar-*", "arn:aws:s3:::aws-codestar-*/*", "arn:aws:s3:::elasticbeanstalk-*", "arn:aws:s3:::elasticbeanstalk-*/*"

122

AWS CodeStar BenutzerhandbuchAWS-verwaltete Richtlinien

] }, { "Sid": "ProjectServices", "Effect": "Allow", "Action": [ "codestar:*Project", "codestar:*Resource*", "codestar:List*", "codestar:Describe*", "codestar:Get*", "codestar:AssociateTeamMember", "codecommit:*", "codepipeline:*", "codedeploy:*", "codebuild:*", "ec2:RunInstances", "autoscaling:*", "cloudwatch:Put*", "ec2:*", "elasticbeanstalk:*", "elasticloadbalancing:*", "iam:ListRoles", "logs:*", "sns:*", "cloud9:CreateEnvironmentEC2", "cloud9:DeleteEnvironmentEC2", "cloud9:DescribeEnvironment*" ], "Resource": "*" }, { "Sid": "ProjectWorkerRoles", "Effect": "Allow", "Action": [ "iam:AttachRolePolicy", "iam:CreateRole", "iam:DeleteRole", "iam:DeleteRolePolicy", "iam:DetachRolePolicy", "iam:GetRole", "iam:PassRole", "iam:PutRolePolicy", "iam:SetDefaultPolicyVersion", "iam:CreatePolicy", "iam:DeletePolicy", "iam:AddRoleToInstanceProfile", "iam:CreateInstanceProfile", "iam:DeleteInstanceProfile", "iam:RemoveRoleFromInstanceProfile" ], "Resource": [ "arn:aws:iam::*:role/CodeStarWorker*", "arn:aws:iam::*:policy/CodeStarWorker*", "arn:aws:iam::*:instance-profile/awscodestar-*" ] }, { "Sid": "ProjectTeamMembers", "Effect": "Allow", "Action": [ "iam:AttachUserPolicy", "iam:DetachUserPolicy" ], "Resource": "*", "Condition": {

123

AWS CodeStar BenutzerhandbuchVom Kunden verwaltete Richtlinien

"ArnEquals": { "iam:PolicyArn": [ "arn:aws:iam::*:policy/CodeStar_*" ] } } }, { "Sid": "ProjectRoles", "Effect": "Allow", "Action": [ "iam:CreatePolicy", "iam:DeletePolicy", "iam:CreatePolicyVersion", "iam:DeletePolicyVersion", "iam:ListEntitiesForPolicy", "iam:ListPolicyVersions" ], "Resource": [ "arn:aws:iam::*:policy/CodeStar_*" ] }, { "Sid": "InspectServiceRole", "Effect": "Allow", "Action": [ "iam:ListAttachedRolePolicies" ], "Resource": [ "arn:aws:iam::*:role/aws-codestar-service-role" ] }, { "Sid": "IAMLinkRole", "Effect": "Allow", "Condition": { "StringLike": { "iam:AWSServiceName": "cloud9.amazonaws.com" } }, "Action": [ "iam:CreateServiceLinkedRole" ], "Resource": "arn:aws:iam::*:role/aws-service-role/cloud9.amazonaws.com/AWSServiceRoleForCloud9*" } ]}

Vom Kunden verwaltete RichtlinienAWS CodeStar erstellt mehrere kundenverwaltete IAM-Richtlinien in Ihrem Namen, wenn Sie ein Projekterstellen. Diese Richtlinien verwalten Zugriffsebenen für Projektteammitglieder. AWS CodeStar erstelltauch eine Berechtigungsgrenze.

AWS CodeStar-Richtlinie für die Eigentümer-RolleAWS CodeStar wendet die CodeStar_project-id_Owner-Richtlinie auf Projektteammitglieder mit derZugriffsebene "Eigentümer" an. Weitere Informationen finden Sie unter AWS CodeStar-Richtlinie für dieEigentümer-Rolle (p. 114).

...

124


{ "Effect": "Allow", "Action": [ ... "codestar:*", ... ], "Resource": [ "arn:aws:codestar:us-east-2:111111111111:project/project-id", "arn:aws:iam::account-id:policy/CodeStar_project-id_Owner" ]},{ "Effect": "Allow", "Action": [ "codestar:DescribeUserProfile", "codestar:ListProjects", "codestar:ListUserProfiles", "codestar:VerifyServiceRole", ... ], "Resource": [ "*" ]},{ "Effect": "Allow", "Action": [ "codestar:*UserProfile", ... ], "Resource": [ "arn:aws:iam::account-id:user/user-name" ]}...

Richtlinie für die AWS CodeStar-Beitragender-RolleAWS CodeStar wendet die CodeStar_project-id_Contributor-Richtlinie auf Projektteammitgliedermit der Zugriffsebene "Beitragender" an. Benutzer mit Beitragender-Zugriff können zu dem Projektbeitragen und das Projekt-Dashboard ändern, können jedoch keine Teammitglieder hinzufügen oderentfernen. Weitere Informationen finden Sie unter Richtlinie für die AWS CodeStar-Beitragender-Rolle (p. 114).

...{ "Effect": "Allow", "Action": [ ... "codestar:Describe*", "codestar:Get*", "codestar:List*", "codestar:PutExtendedAccess", ... ], "Resource": [ "arn:aws:codestar:us-east-2:111111111111:project/project-id", "arn:aws:iam::account-id:policy/CodeStar_project-id_Contributor" ]},{ "Effect": "Allow",

125


"Action": [ "codestar:DescribeUserProfile", "codestar:ListProjects", "codestar:ListUserProfiles", "codestar:VerifyServiceRole", ... ], "Resource": [ "*" ]},{ "Effect": "Allow", "Action": [ "codestar:*UserProfile", ... ], "Resource": [ "arn:aws:iam::account-id:user/user-name" ]}...

AWS CodeStar-Richtlinie für die BetrachterrolleAWS CodeStar wendet die CodeStar_project-id_Viewer-Richtlinie auf Projektteammitglieder mitder Zugriffsebene "Betrachter" an. Benutzer mit Betrachterzugriff können ein Projekt in AWS CodeStaranzeigen, jedoch nicht dessen Ressourcen ändern oder Teammitglieder hinzufügen oder entfernen.Weitere Informationen finden Sie unter AWS CodeStar-Richtlinie für die Betrachterrolle (p. 114).

...{ "Effect": "Allow", "Action": [ ... "codestar:Describe*", "codestar:Get*", "codestar:List*", ... ], "Resource": [ "arn:aws:codestar:us-east-2:111111111111:project/project-id", "arn:aws:iam::account-id:policy/CodeStar_project-id_Viewer" ]},{ "Effect": "Allow", "Action": [ "codestar:DescribeUserProfile", "codestar:ListProjects", "codestar:ListUserProfiles", "codestar:VerifyServiceRole", ... ], "Resource": [ "*" ]},{ "Effect": "Allow", "Action": [ "codestar:*UserProfile", ...

126


], "Resource": [ "arn:aws:iam::account-id:user/user-name" ]}...

AWS CodeStar-Berechtigungsgrenzen-RichtlinieWenn Sie ein AWS CodeStar-Projekt nach 6. Dezember 2018 PDT erstellen, erstellt AWS CodeStareine Berechtigungsgrenzen-Richtlinie für Ihr Projekt. Diese Richtlinie verhindert die Eskalation vonBerechtigungen auf Ressourcen außerhalb des Projekts. Es handelt sich um eine dynamische Richtlinie,die mit der Entwicklung des Projekts aktualisiert wird. Der genaue Inhalt der Richtlinie hängt von der Artdes Projekts ab, das Sie erstellen. Die folgende Richtlinie ist ein Beispiel. Weitere Informationen finden Sieunter IAM-Berechtigungsgrenze (p. 115).

{ "Version": "2012-10-17", "Statement": [ { "Sid": "1", "Effect": "Allow", "Action": [ "s3:GetObject" ], "Resource": [ "arn:aws:s3:::*/AWSLogs/*/Config/*" ] }, { "Sid": "2", "Effect": "Allow", "Action": [ "*" ], "Resource": [ "arn:aws:codestar:us-east-1:account-id:project/project-id", "arn:aws:cloudformation:us-east-1:account-id:stack/awscodestar-project-id-lambda/eefbbf20-c1d9-11e8-8a3a-500c28b4e461", "arn:aws:cloudformation:us-east-1:account-id:stack/awscodestar-project-id/4b80b3f0-c1d9-11e8-8517-500c28b236fd", "arn:aws:codebuild:us-east-1:account-id:project/project-id", "arn:aws:codecommit:us-east-1:account-id:project-id", "arn:aws:codepipeline:us-east-1:account-id:project-id-Pipeline", "arn:aws:execute-api:us-east-1:account-id:7rlst5mrgi", "arn:aws:iam::account-id:role/CodeStarWorker-project-id-CloudFormation", "arn:aws:iam::account-id:role/CodeStarWorker-project-id-CloudWatchEventRule", "arn:aws:iam::account-id:role/CodeStarWorker-project-id-CodeBuild", "arn:aws:iam::account-id:role/CodeStarWorker-project-id-CodePipeline", "arn:aws:iam::account-id:role/CodeStarWorker-project-id-Lambda", "arn:aws:lambda:us-east-1:account-id:function:awscodestar-project-id-lambda-GetHelloWorld-KFKTXYNH9573", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-app", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe" ] }, { "Sid": "3", "Effect": "Allow", "Action": [ "apigateway:GET", "config:Describe*", "config:Get*",

127

AWS CodeStar BenutzerhandbuchEingebundene Richtlinien

"config:List*", "config:Put*", "logs:CreateLogGroup", "logs:CreateLogStream", "logs:DescribeLogGroups", "logs:PutLogEvents" ], "Resource": [ "*" ] } ]}

Eingebundene RichtlinienAWS CodeStar erstellt mehrere eingebundene IAM-Richtlinien, wenn Sie ein Projekt erstellen. DieseRichtlinien werden auf die Auftragnehmerrollen angewendet, die andere AWS-Services zum Erstellen vonProjektressourcen verwenden.

AWS CloudFormation-Auftragnehmerrollen-RichtlinieFür AWS CodeStar-Projekte, die nach dem 6. Dezember 2018 PDT erstellt wurden, erstellt AWS CodeStareine eingebundene Richtlinie für eine Auftragnehmerrolle, die AWS CloudFormation-Ressourcen fürIhr AWS CodeStar-Projekt erstellt. Der genaue Inhalt der Richtlinie hängt von der Art der erforderlichenRessourcen für Ihr Projekt ab. Die folgende Richtlinie ist ein Beispiel. Weitere Informationen finden Sieunter IAM-Richtlinien für Auftragnehmerrollen (p. 114).

{{ "Statement": [ { "Action": [ "s3:PutObject", "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::aws-codestar-region-id-account-id-project-id", "arn:aws:s3:::aws-codestar-region-id-account-id-project-id/*" ], "Effect": "Allow" }, { "Action": [ "apigateway:DELETE", "apigateway:GET", "apigateway:PATCH", "apigateway:POST", "apigateway:PUT", "codedeploy:CreateApplication", "codedeploy:CreateDeployment", "codedeploy:CreateDeploymentConfig", "codedeploy:CreateDeploymentGroup", "codedeploy:DeleteApplication", "codedeploy:DeleteDeployment", "codedeploy:DeleteDeploymentConfig", "codedeploy:DeleteDeploymentGroup", "codedeploy:GetDeployment", "codedeploy:GetDeploymentConfig", "codedeploy:GetDeploymentGroup", "codedeploy:RegisterApplicationRevision",

128


"codestar:SyncResources", "config:DeleteConfigRule", "config:DescribeConfigRules", "config:ListTagsForResource", "config:PutConfigRule", "config:TagResource", "config:UntagResource", "dynamodb:CreateTable", "dynamodb:DeleteTable", "dynamodb:DescribeContinuousBackups", "dynamodb:DescribeTable", "dynamodb:DescribeTimeToLive", "dynamodb:ListTagsOfResource", "dynamodb:TagResource", "dynamodb:UntagResource", "dynamodb:UpdateContinuousBackups", "dynamodb:UpdateTable", "dynamodb:UpdateTimeToLive", "ec2:AssociateIamInstanceProfile", "ec2:AttachVolume", "ec2:CreateSecurityGroup", "ec2:createTags", "ec2:DescribeIamInstanceProfileAssociations", "ec2:DescribeInstances", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DetachVolume", "ec2:DisassociateIamInstanceProfile", "ec2:ModifyInstanceAttribute", "ec2:ModifyInstanceCreditSpecification", "ec2:ModifyInstancePlacement", "ec2:MonitorInstances", "ec2:ReplaceIamInstanceProfileAssociation", "ec2:RunInstances", "ec2:StartInstances", "ec2:StopInstances", "ec2:TerminateInstances", "events:DeleteRule", "events:DescribeRule", "events:ListTagsForResource", "events:PutRule", "events:PutTargets", "events:RemoveTargets", "events:TagResource", "events:UntagResource", "kinesis:AddTagsToStream", "kinesis:CreateStream", "kinesis:DecreaseStreamRetentionPeriod", "kinesis:DeleteStream", "kinesis:DescribeStream", "kinesis:IncreaseStreamRetentionPeriod", "kinesis:RemoveTagsFromStream", "kinesis:StartStreamEncryption", "kinesis:StopStreamEncryption", "kinesis:UpdateShardCount", "lambda:CreateAlias", "lambda:CreateFunction", "lambda:DeleteAlias", "lambda:DeleteFunction", "lambda:DeleteFunctionConcurrency", "lambda:GetFunction", "lambda:GetFunctionConfiguration", "lambda:ListTags", "lambda:ListVersionsByFunction", "lambda:PublishVersion", "lambda:PutFunctionConcurrency",

129


"lambda:TagResource", "lambda:UntagResource", "lambda:UpdateAlias", "lambda:UpdateFunctionCode", "lambda:UpdateFunctionConfiguration", "s3:CreateBucket", "s3:DeleteBucket", "s3:DeleteBucketWebsite", "s3:PutAccelerateConfiguration", "s3:PutAnalyticsConfiguration", "s3:PutBucketAcl", "s3:PutBucketCORS", "s3:PutBucketLogging", "s3:PutBucketNotification", "s3:PutBucketPublicAccessBlock", "s3:PutBucketVersioning", "s3:PutBucketWebsite", "s3:PutEncryptionConfiguration", "s3:PutInventoryConfiguration", "s3:PutLifecycleConfiguration", "s3:PutMetricsConfiguration", "s3:PutReplicationConfiguration", "sns:CreateTopic", "sns:DeleteTopic", "sns:GetTopicAttributes", "sns:ListSubscriptionsByTopic", "sns:ListTopics", "sns:SetSubscriptionAttributes", "sns:Subscribe", "sns:Unsubscribe", "sqs:CreateQueue", "sqs:DeleteQueue", "sqs:GetQueueAttributes", "sqs:GetQueueUrl", "sqs:ListQueueTags", "sqs:TagQueue", "sqs:UntagQueue" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "lambda:AddPermission", "lambda:RemovePermission" ], "Resource": [ "arn:aws:lambda:region-id:account-id:function:awscodestar-*" ], "Effect": "Allow" }, { "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::account-id:role/CodeStar-project-id*" ], "Effect": "Allow" }, { "Condition": { "StringEquals": { "iam:PassedToService": "codedeploy.amazonaws.com" } },

130


"Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::account-id:role/CodeStarWorker-project-id-CodeDeploy" ], "Effect": "Allow" }, { "Action": [ "cloudformation:CreateChangeSet" ], "Resource": [ "arn:aws:cloudformation:region-id:aws:transform/Serverless-2016-10-31", "arn:aws:cloudformation:region-id:aws:transform/CodeStar" ], "Effect": "Allow" }, { "Action": [ "iam:CreateServiceLinkedRole", "iam:GetRole", "iam:DeleteRole", "iam:DeleteUser" ], "Resource": "*", "Effect": "Allow" }, { "Condition": { "StringEquals": { "iam:PermissionsBoundary": "arn:aws:iam::account-id:policy/CodeStar_project-id_PermissionsBoundary" } }, "Action": [ "iam:AttachRolePolicy", "iam:AttachUserPolicy", "iam:CreateRole", "iam:CreateUser", "iam:DeleteRolePolicy", "iam:DeleteUserPolicy", "iam:DetachUserPolicy", "iam:DetachRolePolicy", "iam:PutUserPermissionsBoundary", "iam:PutRolePermissionsBoundary" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "kms:CreateKey", "kms:CreateAlias", "kms:DeleteAlias", "kms:DisableKey", "kms:EnableKey", "kms:UpdateAlias", "kms:TagResource", "kms:UntagResource" ], "Resource": "*", "Effect": "Allow" }, { "Condition": {

131


"StringEquals": { "ssm:ResourceTag/awscodestar:projectArn": "arn:aws:codestar:project-id:account-id:project/project-id" } }, "Action": [ "ssm:GetParameter*" ], "Resource": "*", "Effect": "Allow" } ]}

Richtlinie für Toolchain-Auftragnehmerrolle (nach 6. Dezember2018 PDT)Für AWS CodeStar-Projekte, die nach dem 6. Dezember 2018 PDT erstellt wurden, erstellt AWS CodeStareine eingebundene Richtlinie für eine Auftragnehmerrolle, die Ressourcen für Ihr Projekt in anderenAWS-Services erstellt. Der genaue Inhalt der Richtlinie hängt von der Art des Projekts ab, das Sieerstellen. Die folgende Richtlinie ist ein Beispiel. Weitere Informationen finden Sie unter IAM-Richtlinien fürAuftragnehmerrollen (p. 114).

{ "Statement": [ { "Action": [ "s3:GetObject", "s3:GetObjectVersion", "s3:GetBucketVersioning", "s3:PutObject*", "codecommit:CancelUploadArchive", "codecommit:GetBranch", "codecommit:GetCommit", "codecommit:GetUploadArchiveStatus", "codecommit:GitPull", "codecommit:UploadArchive", "codebuild:StartBuild", "codebuild:BatchGetBuilds", "codebuild:StopBuild", "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "cloudformation:DescribeStacks", "cloudformation:DescribeChangeSet", "cloudformation:CreateChangeSet", "cloudformation:DeleteChangeSet", "cloudformation:ExecuteChangeSet", "codepipeline:StartPipelineExecution", "lambda:ListFunctions", "lambda:InvokeFunction", "sns:Publish" ], "Resource": [ "*" ], "Effect": "Allow" }, { "Action": [ "iam:PassRole"

132


], "Resource": [ "*" ], "Effect": "Allow" }, { "Action": [ "kms:GenerateDataKey*", "kms:Encrypt", "kms:Decrypt" ], "Resource": [ "*" ], "Effect": "Allow" } ]}

CodeBuild-Auftragnehmerrollenrichtlinie (vor 6. Dezember 2018PDT)Wenn Ihr AWS CodeStar-Projekt vor dem 6. Dezember 2018 PDT erstellt wurde, hat AWS CodeStar eineeingebundene Richtlinie für eine CodeBuild-Auftragnehmerrolle erstellt. Die folgende Richtlinienanweisungist ein Beispiel.

{ "Statement": [ { "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "s3:PutObject", "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe/*", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-app", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-app/*" ], "Effect": "Allow" }, { "Action": [ "codecommit:GitPull" ], "Resource": [ "arn:aws:codecommit:us-east-1:account-id:project-id" ], "Effect": "Allow" }, {

133


"Action": [ "kms:GenerateDataKey*", "kms:Encrypt", "kms:Decrypt" ], "Resource": [ "arn:aws:kms:us-east-1:account-id:alias/aws/s3" ], "Effect": "Allow" } ]}

CodePipeline-Auftragnehmerrollenrichtlinie (vor 6. Dezember2018 PDT)Wenn Ihr AWS CodeStar-Projekt vor dem 6. Dezember 2018 PDT erstellt wurde, hat AWS CodeStar eineeingebundene Richtlinie für eineCodePipeline-Workerrolle erstellt. Die folgende Richtlinienanweisung ist einBeispiel.

{ "Statement": [ { "Action": [ "s3:GetObject", "s3:GetObjectVersion", "s3:GetBucketVersioning", "s3:PutObject" ], "Resource": [ "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe/*" ], "Effect": "Allow" }, { "Action": [ "codecommit:CancelUploadArchive", "codecommit:GetBranch", "codecommit:GetCommit", "codecommit:GetUploadArchiveStatus", "codecommit:UploadArchive" ], "Resource": [ "arn:aws:codecommit:us-east-1:account-id:project-id" ], "Effect": "Allow" }, { "Action": [ "codebuild:StartBuild", "codebuild:BatchGetBuilds", "codebuild:StopBuild" ], "Resource": [ "arn:aws:codebuild:us-east-1:account-id:project/project-id" ], "Effect": "Allow" }, { "Action": [ "cloudformation:DescribeStacks", "cloudformation:DescribeChangeSet",

134


"cloudformation:CreateChangeSet", "cloudformation:DeleteChangeSet", "cloudformation:ExecuteChangeSet" ], "Resource": [ "arn:aws:cloudformation:us-east-1:account-id:stack/awscodestar-project-id-lambda/*" ], "Effect": "Allow" }, { "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::account-id:role/CodeStarWorker-project-id-CloudFormation" ], "Effect": "Allow" } ]}

AWS CloudFormation-Auftragnehmerrollenrichtlinie (vor 6.Dezember 2018 PDT)Wenn Ihr AWS CodeStar-Projekt vor dem 6. Dezember 2018 PDT erstellt wurde, hat AWS CodeStareine eingebundene Richtlinie für eine AWS CloudFormation-Auftragnehmerrolle erstellt. Die folgendeRichtlinienanweisung ist ein Beispiel.

{ "Statement": [ { "Action": [ "s3:PutObject", "s3:GetObject", "s3:GetObjectVersion" ], "Resource": [ "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe", "arn:aws:s3:::aws-codestar-us-east-1-account-id-project-id-pipe/*" ], "Effect": "Allow" }, { "Action": [ "codestar:SyncResources", "lambda:CreateFunction", "lambda:DeleteFunction", "lambda:AddPermission", "lambda:UpdateFunction", "lambda:UpdateFunctionCode", "lambda:GetFunction", "lambda:GetFunctionConfiguration", "lambda:UpdateFunctionConfiguration", "lambda:RemovePermission", "lambda:listTags", "lambda:TagResource", "lambda:UntagResource", "apigateway:*", "dynamodb:CreateTable", "dynamodb:DeleteTable", "dynamodb:DescribeTable", "kinesis:CreateStream",

135


"kinesis:DeleteStream", "kinesis:DescribeStream", "sns:CreateTopic", "sns:DeleteTopic", "sns:ListTopics", "sns:GetTopicAttributes", "sns:SetTopicAttributes", "s3:CreateBucket", "s3:DeleteBucket", "config:DescribeConfigRules", "config:PutConfigRule", "config:DeleteConfigRule", "ec2:*", "autoscaling:*", "elasticloadbalancing:*", "elasticbeanstalk:*" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::account-id:role/CodeStarWorker-project-id-Lambda" ], "Effect": "Allow" }, { "Action": [ "cloudformation:CreateChangeSet" ], "Resource": [ "arn:aws:cloudformation:us-east-1:aws:transform/Serverless-2016-10-31", "arn:aws:cloudformation:us-east-1:aws:transform/CodeStar" ], "Effect": "Allow" } ]}

CloudWatch-Ereignisse-Auftragnehmerrollenrichtlinie (vor 6.Dezember 2018 PDT)Wenn Ihr AWS CodeStar-Projekt vor dem 6. Dezember 2018 PDT erstellt wurde, hat AWS CodeStareine eingebundene Richtlinie für eine CloudWatch-Ereignisse-Auftragnehmerrolle erstellt. Die folgendeRichtlinienanweisung ist ein Beispiel.

{ "Statement": [ { "Action": [ "codepipeline:StartPipelineExecution" ], "Resource": [ "arn:aws:codepipeline:us-east-1:account-id:project-id-Pipeline" ], "Effect": "Allow" } ]}

136

AWS CodeStar BenutzerhandbuchIAM-Benutzerzugriff auf AWS CodeStar

IAM-Benutzerzugriff auf AWS CodeStarWenn Sie einen IAM-Benutzer einem Projekt hinzufügen und für diesen eine Rolle auswählen, wendetAWS CodeStar auf den IAM-Benutzer die entsprechende Richtlinie automatisch an. Für IAM-Benutzer istes nicht erforderlich, Richtlinien oder Berechtigungen in IAM direkt anzufügen oder zu verwalten.

Einen IAM-Benutzer zu Ihrem AWS CodeStar-ProjekthinzufügenNachdem Sie Ihr AWS CodeStar-Projekt erstellt haben, gewähren Sie IAM-Benutzern den Zugriff auf IhrProjekt. Als IAM-Benutzer mit der Eigentümerrolle in einem AWS CodeStar-Projekt oder der auf Ihren IAM-Benutzer angewandten AWSCodeStarFullAccess-Richtlinie können Sie weitere IAM-Benutzer zumProjektteam hinzufügen. Wenn Sie die Rolle auf Projektebene für das Teammitglied auswählen, fügt AWSCodeStar die entsprechende verwaltete Richtlinie an den IAM-Benutzer an, basierend auf der von Ihnengewählten Rolle.

Entfernen eines IAM-Benutzers aus Ihrem AWSCodeStar;-Projekt.Wenn Sie ein Projekt löschen, entfernt AWS CodeStar die Richtlinien, die automatisch auf IAM-Benutzerangewendet wurden, die Sie als Teammitglieder hinzugefügt haben. Für IAM-Benutzer ist es nichterforderlich, Richtlinien oder Berechtigungen in IAM direkt zu trennen oder zu verwalten.

Anfügen einer Inline-Richtlinie an einen IAM-BenutzerWenn Sie einem Projekt einen Benutzer hinzufügen, fügt AWS CodeStar automatisch die verwalteteRichtlinie für das Projekt an, die der Rolle des Benutzers entspricht. Sie sollten eine von AWS CodeStarverwaltete Richtlinie für ein Projekt nicht manuell an einen IAM-Benutzer anfügen. Mit Ausnahme vonAWSCodeStarFullAccess wird nicht empfohlen, Richtlinien anzufügen, die die Berechtigungen einesIAM-Benutzers in einem AWS CodeStar-Projekt ändern. Wenn Sie sich entscheiden, Ihre eigenenRichtlinien zu erstellen und anzufügen, gehen Sie wie folgt vor:

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

2. Wählen Sie in der IAM-Konsole im Navigationsfenster Users (Benutzer) den Benutzer aus, dem Sieweitere Richtlinien anfügen möchten.

3. Wählen Sie auf der Registerkarte Permissions die Option Add permissions. Wählen Sie Attach existingpolicies directly (Vorhandene Richtlinien direkt anfügen), wählen Sie die gewünschte Richtlinie unddann Attach Policy (Richtlinie anfügen).

Wenn Sie zum Beispiel einem Benutzer Ihre eigene benutzerdefinierte Richtlinie hinzufügen möchten,wählen Sie den Richtliniennamen aus der Liste der Richtlinien.

4. Wenn Sie keine vorhandene Richtlinie anfügen, sondern Ihre eigene benutzerdefinierte Richtlinieerstellen möchten, wählen Sie auf der Registerkarte Permissions (Berechtigungen) die Option Addinline policy (Inline-Richtlinie hinzufügen). Wählen Sie Custom Policy und dann Select aus.

Geben Sie unter Policy Name (Richtlinienname) einen Namen für diese Richtlinie ein. Geben Sie imFeld Policy Document (Richtliniendokument) eine Richtlinie ein, die diesem Format entspricht, undwählen Sie dann Apply Policy (Richtlinie anwenden) aus.

{ "Version": "2012-10-17",

137



AWS CodeStar BenutzerhandbuchZugriff für verbundene Benutzer auf AWS CodeStar

"Statement" : [ { "Effect" : "Allow", "Action" : [ "action-statement" ], "Resource" : [ "resource-statement" ] }, { "Effect" : "Allow", "Action" : [ "action-statement" ], "Resource" : [ "resource-statement" ] } ]}

Geben Sie in der vorherigen Anweisung für action-statement und resource-statementdie AWS CodeStar-Aktionen und -Ressourcen an, die der IAM-Benutzer durchführen bzw. auf dieer zugreifen darf. (Standardmäßig hat der IAM-Benutzer keine Berechtigungen, es sei denn, eineentsprechende Allow-Anweisung ist explizit festgelegt. Wenn Sie eine von einer anderen Richtlinie,etwa der Richtlinie für eine AWS CodeStar-Rolle, gewährte Berechtigung aufheben möchten, wählenSie Deny anstelle von Allow.) Sie können bei Bedarf Anweisungen hinzufügen. In den folgendenAbschnitten wird das Format der zulässigen Aktionen und Ressourcen für AWS CodeStar beschrieben.In diesen Abschnitten werden Syntaxbeispiele bereitgestellt.

Zugriff für verbundene Benutzer auf AWS CodeStarAnstatt einen IAM-Benutzer anzulegen oder den Root-Benutzer zu verwenden, können SieBenutzeridentitäten aus dem AWS Directory Service, Ihrem Unternehmensbenutzerverzeichnis, einemWeb-Identitätsanbieter oder IAM-Benutzer mit Rollen verwenden. Diese werden als verbundene Benutzerbezeichnet.

Gewähren Sie verbundenen Benutzern Zugriff auf Ihr AWS CodeStar-Projekt, indem Sie die in AWSCodeStar Level Policies and Permissions (p. 113) beschriebenen verwalteten Richtlinien manuell an dieIAM-Rolle des Benutzers anfügen. Sie fügen die Eigentümer-, Beitragender- oder Betrachter-Richtliniehinzu, nachdem AWS CodeStar Ihre Projektressourcen und IAM-Rollen erstellt hat.

Voraussetzungen:

• Sie müssen einen Identitätsanbieter eingerichtet haben. Weitere Informationen finden Sie unter IAM-Identitätsanbieter anlegen. Beispielsweise können Sie einen SAML-Identitätsanbieter einrichten und dieAWS-Authentifizierung über den Anbieter einrichten lassen. Weitere Informationen zur SAML-Föderationfinden Sie unter Über die SAML 2.0-basierte Föderation.

• Sie müssen eine Rolle angelegt haben, die ein verbundener Benutzer übernehmen kann, wenn derZugriff über einen Identitätsanbieter angefordert wird. Der Rolle, die es verbundenen Benutzernermöglicht, die Rolle zu übernehmen, muss eine STS-Vertrauensrichtlinie angefügt werden. WeitereInformationen zum Thema Verbundene Benutzer und Rollen finden Sie im IAM-Benutzerhandbuch.

• Sie müssen Ihr AWS CodeStar-Projekt erstellt haben und die Projekt-ID kennen.

Weitere Informationen zum Anlegen einer Rolle für Identitätsanbieter finden Sie unter Anlegen einer Rollefür einen externen Identitätsanbieter (Föderation).

138

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_saml.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_access-management.html#intro-access-roles

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-idp.html

AWS CodeStar BenutzerhandbuchAnfügen der verwalteten RichtlinieAWSCodeStarFullAccess an dieRolle des verbundenen Benutzers.

Anfügen der verwalteten RichtlinieAWSCodeStarFullAccess an die Rolle desverbundenen Benutzers.Erteilen Sie einem verbundenen Benutzer Berechtigungen zum Erstellen eines Projekts, indem Sie dieverwaltete Richtlinie AWSCodeStarFullAccess anfügen. Um diese Schritte auszuführen, müssenSie sich entweder als Root-Benutzer, IAM-Administratorbenutzer im Konto oder als IAM-Benutzer oderverbundener Benutzer mit der zugehörigen AdministratorAccess verwalteten Richtlinie oder ähnlichemin der Konsole angemeldet haben.

Note

Nachdem Sie das Projekt erstellt haben, werden Ihre Berechtigungen des Projektverantwortlichennicht automatisch übernommen. Verwenden Sie eine Rolle mit administrativen Berechtigungenfür Ihr Konto und fügen Sie die Eigentümer-verwaltete Richtlinie hinzu, wie in Fügen Sie dieverwaltete AWS CodeStar Betrachter/Beitragender/Eigentümer-Richtlinie Ihres Projekts der Rolledes verbundenen Benutzers hinzu. (p. 139) beschrieben.

1. Öffnen Sie die IAM-Konsole. Wählen Sie im Navigationsbereich Policies aus.2. Geben Sie im Suchfeld AWSCodeStarFullAccess ein. Der Richtlinienname wird angezeigt, mit

einem Richtlinientyp AWS managed (AWS verwaltet). Sie können die Richtlinie erweitern, um dieBerechtigungen in der Richtlinienanweisung anzuzeigen.

3. Aktivieren Sie die runde Optionsschaltfläche neben Richtlinie und wählen Sie unter Policy actions(Richtlinienaktionen) Attach (Anfügen) aus.

4. Wählen Sie auf der Seite Summary (Übersicht) die Registerkarte Attached entities (AngefügteElemente). Wählen Sie Attach (Anfügen) aus.

5. Filtern Sie auf der Seite Attach Policy (Richtlinie anfügen) nach der Rolle des verbundenen Benutzersim Suchfeld. Markieren Sie das Kontrollkästchen neben dem Namen der Rolle und wählen Sie dannAttach policy (Richtlinie anfügen). Die Registerkarte Attached entities (Angefügte Elemente) zeigt dieneue Anfügung.

Fügen Sie die verwaltete AWS CodeStar Betrachter/Beitragender/Eigentümer-Richtlinie Ihres Projekts derRolle des verbundenen Benutzers hinzu.Gewähren Sie verbundenen Benutzern Zugriff auf Ihr Projekt, indem Sie der Rolle des Benutzers dieentsprechenden, vom Eigentümer, Beitragenden oder Betrachter verwalteten Richtlinien hinzufügen. Dieverwaltete Richtlinie gibt die entsprechende Berechtigungsstufe vor. Im Gegensatz zu IAM-Benutzernmüssen Sie verwaltete Richtlinien für verbundene Benutzer manuell hinzufügen und trennen. Diesentspricht der Zuweisung von Projektberechtigungen an Teammitglieder in AWS CodeStar. Um dieseSchritte auszuführen, müssen Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzer imKonto oder als IAM-Benutzer oder verbundener Benutzer mit der zugehörigen AdministratorAccessverwalteten Richtlinie oder ähnlichem in der Konsole angemeldet haben.

Voraussetzungen:

• Sie müssen eine Rolle angelegt haben oder über eine bestehende Rolle verfügen, die Ihr verbundenerBenutzer übernimmt.

• Sie müssen wissen, welche Berechtigungsstufe Sie vergeben möchten. Die verwalteten Richtlinien, dieden Rollen Eigentümer, Beitragender und Betrachter angefügt sind, bieten rollenbasierte Berechtigungenfür Ihr Projekt.

139

AWS CodeStar BenutzerhandbuchTrennen einer von AWS CodeStar verwalteten

Richtlinie von der Rolle des verbundenen Benutzers.

• Ihr AWS CodeStar-Projekt muss bereits erstellt worden sein. Die verwaltete Richtlinie ist in IAM erst nachder Erstellung des Projekts verfügbar.

1. Öffnen Sie die IAM-Konsole. Wählen Sie im Navigationsbereich Policies aus.2. Geben Sie Ihrem Projekt-ID in das Suchfeld ein. Der Richtlinienname Ihres Projekts wird angezeigt, mit

einem Richtlinientyp Customer managed (Kunden verwaltet). Sie können die Richtlinie erweitern, umdie Berechtigungen in der Richtlinienanweisung anzuzeigen.

3. Wählen Sie eine dieser verwalteten Richtlinien. In diesem Beispiel wird eine von einem Betrachterverwaltete Richtlinie angefügt. Aktivieren Sie die runde Optionsschaltfläche neben Richtlinie undwählen Sie unter Policy actions (Richtlinienaktionen) Attach (Anfügen) aus.


5. Filtern Sie auf der Seite Attach Policy (Richtlinie anfügen) nach der Rolle des verbundenen Benutzersim Suchfeld. Markieren Sie das Kontrollkästchen neben dem Namen der Rolle und wählen Sie dannAttach policy (Richtlinie anfügen). Die Registerkarte Attached entities (Angefügte Elemente) zeigt dieneue Anfügung.

Trennen einer von AWS CodeStar verwaltetenRichtlinie von der Rolle des verbundenen Benutzers.Bevor Sie Ihr AWS CodeStar-Projekt löschen, müssen Sie alle verwalteten Richtlinien, die Sie der Rolleeines verbundenen Benutzers hinzugefügt haben, manuell trennen. Um diese Schritte auszuführen,müssen Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzer im Konto oder als IAM-Benutzeroder verbundener Benutzer mit der zugehörigen AdministratorAccess verwalteten Richtlinie oderähnlichem in der Konsole angemeldet haben.

1. Öffnen Sie die IAM-Konsole. Wählen Sie im Navigationsbereich Policies aus.2. Geben Sie Ihrem Projekt-ID in das Suchfeld ein.3. Aktivieren Sie die runde Optionsschaltfläche neben Richtlinie und wählen Sie unter Policy actions

(Richtlinienaktionen) Attach (Anfügen) aus.4. Wählen Sie auf der Seite Summary (Übersicht) die Registerkarte Attached entities (Angefügte

Elemente).5. Filtern Sie die Rolle des verbundenen Benutzers im Suchfeld. Wählen Sie Detach (Trennen) aus.

Anfügen einer von AWS Cloud9 verwalteten Richtliniean die Rolle des verbundenen Benutzers.Gewähren Sie verbundenen Benutzern Zugriff auf Ihre AWS Cloud9-Umgebung, indem Sie der Rolle derBenutzer die AWSCloud9User-verwaltete Richtlinie hinzufügen. Im Gegensatz zu IAM-Benutzern müssenSie verwaltete Richtlinien für verbundene Benutzer manuell hinzufügen und trennen. Um diese Schritteauszuführen, müssen Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzer im Konto oderals IAM-Benutzer oder verbundener Benutzer mit der zugehörigen AdministratorAccess verwaltetenRichtlinie oder ähnlichem in der Konsole angemeldet haben.

Voraussetzungen:

• Sie müssen eine Rolle angelegt haben oder über eine bestehende Rolle verfügen, die Ihr verbundenerBenutzer übernimmt.

• Sie müssen wissen, welche Berechtigungsstufe Sie vergeben möchten:• Die AWSCloud9User verwaltete Richtlinie ermöglicht es dem Benutzer, Folgendes zu tun:

140

AWS CodeStar BenutzerhandbuchTrennen einer von AWS Cloud9 verwalteten

Richtlinie von der Rolle des verbundenen Benutzers.

• Erstellen Sie ihre eigene AWS Cloud9-Entwicklungsumgebung• Abrufen von Informationen über ihre Umgebungen.• Ändern der Einstellungen für ihre Umgebungen.

• Die AWSCloud9Administrator verwaltete Richtlinie ermöglicht es dem Benutzer, Folgendes für sichselbst oder andere zu tun:• Erstellen von Umgebungen.• Abrufen von Informationen zu Umgebungen.• Löschen von Umgebungen.• Ändern der Einstellungen von Umgebungen.

1. Öffnen Sie die IAM-Konsole. Wählen Sie im Navigationsbereich Policies aus.2. Geben Sie den Namen der Richtlinie in das Suchfeld ein. Dieses Beispiel sucht die AWSCloud9User-

verwaltete Richtlinie. Der verwaltete Richtlinie wird angezeigt, mit einem Richtlinientyp AWSmanaged (AWS verwaltet). Sie können die Richtlinie erweitern, um die Berechtigungen in derRichtlinienanweisung anzuzeigen.

3. Wählen Sie eine dieser verwalteten Richtlinien. In diesem Beispiel wird die AWSCloud9User-verwaltete Richtlinie angefügt. Aktivieren Sie die runde Optionsschaltfläche neben Richtlinie undwählen Sie unter Policy actions (Richtlinienaktionen) Attach (Anfügen) aus.


5. Filtern Sie auf der Seite Attach Policy (Richtlinie anfügen) nach der Rolle des verbundenen Benutzersim Suchfeld. Wählen Sie das Kontrollkästchen neben dem Namen der Rolle aus und anschließendAttach policy (Richtlinie anfügen). Die Registerkarte Attached entities (Angefügte Elemente) zeigt dieneue Anfügung.

Trennen einer von AWS Cloud9 verwalteten Richtlinievon der Rolle des verbundenen Benutzers.Um die AWS Cloud9-Berechtigungen des verbundenen Benutzers zu entfernen, trennen Sie die Richtlinie.Um diese Schritte auszuführen, müssen Sie sich entweder als Root-Benutzer, IAM-Administratorbenutzerim Konto oder als IAM-Benutzer oder verbundener Benutzer mit der zugehörigen AdministratorAccessverwalteten Richtlinie oder ähnlichem in der Konsole angemeldet haben.

1. Öffnen Sie die IAM-Konsole. Wählen Sie im Navigationsbereich Policies aus.2. Geben Sie Ihren Projektnamen in das Suchfeld ein.3. Aktivieren Sie die runde Optionsschaltfläche neben Richtlinie und wählen Sie unter Policy actions

(Richtlinienaktionen) Attach (Anfügen) aus.4. Wählen Sie auf der Seite Summary (Übersicht) die Registerkarte Attached entities (Angefügte

Elemente).5. Filtern Sie die Rolle des verbundenen Benutzers im Suchfeld. Wählen Sie Detach (Trennen) aus.

141

AWS CodeStar BenutzerhandbuchAWS CodeStar-Informationen in CloudTrail

Protokollieren von AWS CodeStar-API-Aufrufen mit AWS CloudTrail

AWS CodeStar ist in AWS CloudTrail integriert, einen Service, der die Aktionen eines Benutzers, einerRolle oder eines AWS-Services in AWS CodeStar aufzeichnet. CloudTrail erfasst alle API-Aufrufe fürAWS CodeStar als Ereignisse. Zu den erfassten Aufrufen gehören Aufrufe von der AWS CodeStar-Konsole und Code-Aufrufe der AWS CodeStar-API-Operationen. Wenn Sie einen Trail erstellen, könnenSie die kontinuierliche Bereitstellung von CloudTrail-Ereignissen an einen Amazon S3-Bucket aktivieren,einschließlich Ereignissen für AWS CodeStar. Auch wenn Sie keinen Trail konfigurieren, können Sie dieneuesten Ereignisse in der CloudTrail-Konsole in Event history (Ereignisverlauf) anzeigen. Mit den vonCloudTrail gesammelten Informationen können Sie die an AWS CodeStar gestellte Anforderung, die IP-Adresse, von der die Anforderung gestellt wurde, den Initiator sowie den Zeitpunkt der Anforderung undandere Angaben bestimmen.

Weitere Informationen zu CloudTrail finden Sie im AWS CloudTrail User Guide.

AWS CodeStar-Informationen in CloudTrailCloudTrail wird beim Erstellen Ihres AWS-Kontos für Sie aktiviert. Die in AWS CodeStar auftretendenAktivitäten werden als CloudTrail-Ereignis zusammen mit anderen AWS-Serviceereignissen in Eventhistory (Ereignisverlauf) aufgezeichnet. Sie können die neusten Ereignisse in Ihrem AWS-Konto anzeigen,suchen und herunterladen. Weitere Informationen finden Sie unter Anzeigen von Ereignissen mit demCloudTrail-API-Ereignisverlauf.

Erstellen Sie für eine fortlaufende Aufzeichnung der Ereignisse in Ihrem AWS-Konto, darunter Ereignissefür AWS CodeStar, einen Trail. Ein Trail ermöglicht CloudTrail die Übermittlung von Protokolldateien aneinen Amazon S3-Bucket. Wenn Sie einen Pfad in der Konsole anlegen, gilt dieser standardmäßig für alleAWS-Regionen. Der Trail protokolliert Ereignisse aus allen Regionen in der AWS-Partition und stellt dieProtokolldateien in dem Amazon S3-Bucket bereit, den Sie angeben. Sie können andere AWS-Serviceskonfigurieren, um die in den CloudTrail-Protokollen erfassten Ereignisdaten weiter zu analysieren undentsprechend zu agieren. Weitere Informationen finden Sie unter:

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

Protokolldateien aus mehreren Konten

Alle AWS CodeStar-Aktionen werden von CloudTrail protokolliert und in der AWS CodeStar-API-Referenzdokumentiert. Zum Beispiel werden durch Aufrufe der Aktionen DescribeProject, UpdateProject undAssociateTeamMember Einträge in den CloudTrail-Protokolldateien generiert.

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.

142

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

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

http://docs.aws.amazon.com/codestar/latest/APIReference

AWS CodeStar BenutzerhandbuchGrundlagen zu AWS CodeStar-Protokolldateieinträgen

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

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

Weitere Informationen finden Sie unter CloudTrail-Element "userIdentity".

Grundlagen zu AWS CodeStar-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 den Aufruf einer CreateProject-Operation in AWS CodeStar demonstriert:

{ "eventVersion": "1.05", "userIdentity": { "type": "AssumedRole", "principalId": "AROAJLIN2OF3UBEXAMPLE:role-name", "arn": "arn:aws:sts::account-ID:assumed-role/role-name/role-session-name", "accountId": "account-ID", "accessKeyId": "ASIAJ44LFQS5XEXAMPLE", "sessionContext": { "attributes": { "mfaAuthenticated": "false", "creationDate": "2017-06-04T23:56:57Z" }, "sessionIssuer": { "type": "Role", "principalId": "AROAJLIN2OF3UBEXAMPLE", "arn": "arn:aws:iam::account-ID:role/service-role/role-name", "accountId": "account-ID", "userName": "role-name" } }, "invokedBy": "codestar.amazonaws.com" }, "eventTime": "2017-06-04T23:56:57Z", "eventSource": "codestar.amazonaws.com", "eventName": "CreateProject", "awsRegion": "region-ID", "sourceIPAddress": "codestar.amazonaws.com", "userAgent": "codestar.amazonaws.com", "requestParameters": { "clientRequestToken": "arn:aws:cloudformation:region-ID:account-ID:stack/stack-name/additional-ID", "id": "project-ID", "stackId": "arn:aws:cloudformation:region-ID:account-ID:stack/stack-name/additional-ID", "description": "AWS CodeStar created project", "name": "project-name", "projectTemplateId": "arn:aws:codestar:region-ID::project-template/project-template-name"

143

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

AWS CodeStar BenutzerhandbuchGrundlagen zu AWS CodeStar-Protokolldateieinträgen

}, "responseElements": { "projectTemplateId": "arn:aws:codestar:region-ID::project-template/project-template-name", "arn": "arn:aws:codestar:us-east-1:account-ID:project/project-ID", "clientRequestToken": "arn:aws:cloudformation:region-ID:account-ID:stack/stack-name/additional-ID", "id": "project-ID" }, "requestID": "7d7556d0-4981-11e7-a3bc-dd5daEXAMPLE", "eventID": "6b0d6e28-7a1e-4a73-981b-c8fdbEXAMPLE", "eventType": "AwsApiCall", "recipientAccountId": "account-ID"}

144


Einschränkungen in AWS CodeStarDie folgende Tabelle beschreibt die Grenzwerte in AWS CodeStar. AWS CodeStar hängt von anderenAWS-Services für die Projektressourcen ab. Einige dieser Service-Einschränkungen können geändertwerden. Informationen zu Einschränkungen, für die Änderungen möglich sind, finden Sie unter Limits fürAWS.

Anzahl der Projekte Maximal 333 Projekte in einem AWS-Konto. Dietatsächliche Begrenzung hängt von anderenService-Abhängigkeiten ab (z. B. der maximalenAnzahl der für Ihr AWS-Konto zulässigen Pipelinesin CodePipeline).

Anzahl der AWS CodeStar-Projekte, zu denen einIAM-Benutzer gehören kann

Maximal 10 pro einzelnem IAM-Benutzer.

Projekt-IDs Projekt-IDs müssen innerhalb eines AWS-Kontoseindeutig sein. Project-IDs müssen mindestens2 und dürfen höchstens 15 Zeichen lang sein.Zulässige Zeichen sind:

Buchstaben a bis z, einschließlich.

Zahlen 0 bis 9, einschließlich.

Das Sonderzeichen - (Minuszeichen).

Alle anderen Zeichen, z. B. Großbuchstaben,Leerzeichen . (Punkt), @ (at-Zeichen) oder _(Unterstrich), sind nicht zulässig.

Projektnamen Projektnamen dürfen maximal 100 Zeichen langsein und dürfen nicht mit einem Leerzeichenbeginnen oder enden.

Projektbeschreibungen Beliebige Kombinationen von Zeichen miteiner Länge zwischen 0 und 1.024 Zeichen.Projektbeschreibungen sind optional.

Teammitglieder in einem AWS CodeStar-Projekt 100

Anzeigename in einem Benutzerprofil Beliebige Kombinationen von Zeichen miteiner Länge zwischen 1 und 100 Zeichen.Anzeigenamen müssen mindestens ein Zeichenenthalten. Dieses Zeichen darf kein Leerzeichensein. Anzeigenamen dürfen nicht mit einemLeerzeichen beginnen oder enden.

E-Mail-Adresse in einem Benutzerprofil Die E-Mail-Adresse muss ein @ enthalten und miteiner gültigen Domänenerweiterung enden.

Federated-, Root-Konto- oder vorübergehenderZugriff auf AWS CodeStar

AWS CodeStar unterstützt keineAnmeldeinformationen für verbundene Benutzeroder vorübergehenden Zugriff. Es wird nichtempfohlen, AWS CodeStar mit einem Stammkontozu verwenden.

145

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html



IAM-Rollen Maximal 5.120 Zeichen in einer verwaltetenRichtlinie, die mit einer IAM-Rolle verbunden ist.

146

AWS CodeStar BenutzerhandbuchFehler beim Erstellen eines Projekts:

Ein Projekt wurde nicht erstellt.

AWS CodeStar-FehlerbehebungDie folgenden Informationen helfen Ihnen möglicherweise bei der Lösung häufiger Probleme in AWSCodeStar.

Themen• Fehler beim Erstellen eines Projekts: Ein Projekt wurde nicht erstellt. (p. 147)• Projekterstellung: Ich sehe einen Fehler, wenn ich versuche, die Amazon EC2-Konfiguration beim

Erstellen eines Projekts zu bearbeiten. (p. 148)• Projektlöschung: Ein AWS CodeStar-Projekt wurde gelöscht, es sind jedoch weiterhin Ressourcen

vorhanden. (p. 148)• Teammanagement-Fehler: Ein IAM-Benutzer konnte nicht zu einem Team in einem AWS CodeStar-

Projekt hinzugefügt werden. (p. 150)• Zugrifffehler: Ein verbundener Benutzer hat keinen Zugriff auf ein AWS CodeStar-Projekt (p. 150)• Zugrifffehler: Ein verbundener Benutzer kann auf eine AWS Cloud9-Umgebung nicht zugreifen oder

diese erstellen. (p. 150)• Zugrifffehler: Ein verbundener Benutzer kann ein AWS CodeStar-Projekt erstellen, aber keine

Projektressourcen anzeigen. (p. 151)• Servicerollen-Problem: Die Servicerolle konnte nicht erstellt werden. (p. 151)• Servicerollen-Problem: Die Servicerolle ist ungültig oder fehlt. (p. 151)• Projektrollen-Problem: Die AWS Elastic Beanstalk Zustandsprüfungen schlagen bei Instances in einem

AWS CodeStar-Projekt fehl (p. 152)• Projektrollen-Problem: Eine Projektrolle ist ungültig oder fehlt. (p. 152)• Projekterweiterungen: Keine Verbindung zu JIRA möglich (p. 153)• GitHub: Kein Zugriff auf den Commit-Verlauf eines Repositorys, Probleme oder Code (p. 153)• AWS CloudFormation: Stapelbildung wegen fehlender Berechtigungen zurückgerollt (p. 153)• AWS CloudFormation ist nicht für die Ausführung von „iam:PassRole“ auf der Lambda Ausführungsrolle

autorisiert. (p. 154)

Fehler beim Erstellen eines Projekts: Ein Projektwurde nicht erstellt.

Problem: Wenn Sie ein Projekt erstellen möchten, erscheint die Meldung, dass die Erstellungfehlgeschlagen ist.

Mögliche Lösungen: Die häufigsten Fehlerursachen sind:

• Ein Projekt mit dieser ID existiert bereits in Ihrem AWS-Konto, möglicherweise in einer anderen AWS-Region.

• Der für die Anmeldung bei der AWS Management Console verwendete IAM-Benutzer verfügt nicht überdie erforderlichen Berechtigungen zum Erstellen eines Projekts.

• Eine oder mehrere der erforderlichen Berechtigungen fehlen in der AWS CodeStar-Servicerolle.

147

AWS CodeStar BenutzerhandbuchProjekterstellung: Ich sehe einen Fehler, wennich versuche, die Amazon EC2-Konfigurationbeim Erstellen eines Projekts zu bearbeiten.

• Sie haben die maximale Grenze für eine oder mehrere Ressourcen für ein Projekt erreicht (z. B.Begrenzung der vom Kunden verwalteten Richtlinien in IAM, Amazon S3-Buckets oder Pipelines inCodePipeline).

Bevor Sie ein Projekt erstellen, vergewissern Sie sich, dass die Richtlinie AWSCodeStarFullAccessauf Ihren IAM-Benutzer angewendet wird. Weitere Informationen finden Sie unter AWS CodeStar-Zugriffsberechtigungen – Referenz (p. 112).

Wenn Sie ein Projekt erstellen, stellen Sie sicher, dass die ID eindeutig ist und die AWS CodeStar-Anforderungen erfüllt. Stellen Sie sicher, dass Sie das Kontrollkästchen AWS CodeStar would likepermission to administer AWS resources on your behalf (AWS CodeStar möchte die Berechtigung, AWS-Ressourcen in Ihrem Namen zu verwalten.) ausgewählt haben.

Öffnen Sie zum Beheben von anderen Problemen die AWS CloudFormation-Konsole, wählen Sie denStack für das Projekt, das Sie erstellen möchten, und anschließend die Registerkarte Events (Ereignisse)aus. Möglicherweise gibt es mehr als einen Stack für ein Projekt. Die Stack-Namen beginnen mitawscodestar-, gefolgt von der Projekt-ID. Stacks sind möglicherweise in der Filteransicht Deleted(Gelöscht) vorhanden. Überprüfen Sie alle Fehlermeldungen in den Stack-Ereignissen und beheben Siedas Problem, das als Ursache dieser Fehler aufgeführt wird.

Projekterstellung: Ich sehe einen Fehler, wenn ichversuche, die Amazon EC2-Konfiguration beimErstellen eines Projekts zu bearbeiten.

Problem: Beim Bearbeiten der Amazon EC2-Konfigurationsoptionen während der Projekterstellung, wirdeine Fehlermeldung angezeigt oder eine Option wird ausgegraut dargestellt und Sie können nicht mit derProjekterstellung fortfahren.

Mögliche Lösungen: Die häufigsten Ursachen für Fehlermeldungen sind:

• Die VPC im Projektvorlage für AWS CodeStar (entweder die Standard-VPC oder die beim Bearbeitender Amazon EC2-Konfiguration verwendete) verfügt über eine Dedicated Instance-Tenancy und derInstance-Typ wird für Dedicated Instances nicht unterstützt. Wählen Sie einen anderen Instance-Typoder eine andere Amazon VPC.

• Ihr AWS-Konto hat keine Amazon VPCs. Möglicherweise haben Sie die Standard-VPC gelöscht undkeine andere erstellt. Öffnen Sie die Amazon VPC-Konsole unter https://console.aws.amazon.com/vpc/,wählen Sie Your VPCs (Ihre VPCs) und stellen Sie sicher, dass mindestens eine VPC konfiguriert ist.Wenn dies nicht der Fall ist, erstellen Sie eine. Weitere Informationen finden Sie unter Amazon VirtualPrivate Cloud Übersicht im Amazon VPC-Handbuch Erste Schritte.

• Das Amazon VPC hat keine Subnetze. Wählen Sie eine andere VPC oder erstellen Sie ein Subnetz fürdie VPC. Weitere Informationen finden Sie unter VPC- und Subnetz-Grundlagen.

Projektlöschung: Ein AWS CodeStar-Projekt wurdegelöscht, es sind jedoch weiterhin Ressourcenvorhanden.

Problem: Ein AWS CodeStar-Projekt wurde gelöscht, die für dieses Projekt erstellten Ressourcen sindjedoch weiterhin vorhanden. Standardmäßig löscht AWS CodeStar-Projektressourcen, wenn das Projekt

148

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

https://docs.aws.amazon.com/AmazonVPC/latest/GettingStartedGuide/ExerciseOverview.html

https://docs.aws.amazon.com/AmazonVPC/latest/GettingStartedGuide/ExerciseOverview.html

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Subnets.html#vpc-subnet-basics

AWS CodeStar BenutzerhandbuchProjektlöschung: Ein AWS CodeStar-Projekt wurde

gelöscht, es sind jedoch weiterhin Ressourcen vorhanden.

gelöscht wird. Einige Ressourcen, wie z. B. Amazon S3-Buckets, werden auch dann beibehalten, wenn derBenutzer das Kontrollkästchen Delete associated resources along with AWS CodeStar project (Löschender zugeordneten Ressourcen zusammen mit dem AWS CodeStar-Projekt.) markiert, da die Buckets Datenenthalten könnten.

Mögliche Lösungen: Öffnen Sie die AWS CloudFormation-Konsole und suchen Sie einen oder mehrereder für die Projekterstellung verwendeten AWS CloudFormation-Stacks. Die Stack-Namen beginnen mitawscodestar-, gefolgt von der Projekt-ID. Die Stacks sind möglicherweise in der Filteransicht Deleted(Gelöscht) vorhanden. Überprüfen Sie die mit dem Stack verknüpften Ereignisse, um die für das Projekterstellten Ressourcen zu finden. Öffnen Sie die Konsole für jede dieser Ressourcen in der AWS-Region,in der das AWS CodeStar-Projekt erstellt wurde, und löschen Sie dann manuell die Ressourcen für diesesgelöschte Projekt.

Zu den Projektressourcen, die möglicherweise erhalten bleiben, gehören:

• Ein oder mehrere Projekt-Buckets in Amazon S3. Im Gegensatz zu anderen Projektressourcen werdenProjekt-Buckets in Amazon S3 nicht gelöscht, wenn das Kontrollkästchen Delete associated AWSresources along with AWS CodeStar project (Löschen der zugeordneten Ressourcen zusammen mit demAWS CodeStar-Projekt) gelöscht wird.

Öffnen Sie die Amazon S3-Konsole unter der Adresse https://console.aws.amazon.com/s3/.• Ein Quell-Repository für Ihr Projekt in CodeCommit.

Öffnen Sie die CodeCommit -Konsole über https://console.aws.amazon.com/codecommit/.• Eine Pipeline für Ihr Projekt in CodePipeline.

Öffnen Sie die CodePipeline-Konsole unter https://console.aws.amazon.com/codepipeline/.• Eine Anwendung und zugehörige Bereitstellungsgruppen in CodeDeploy.

Öffnen Sie die CodeDeploy-Konsole über https://console.aws.amazon.com/codedeploy/.• Eine Anwendung und zugehörige Umgebungen in AWS Elastic Beanstalk.

Öffnen Sie die Elastic Beanstalk-Konsole unter der Adresse https://console.aws.amazon.com/elasticbeanstalk/.

• Eine Funktion in AWS Lambda.

Öffnen Sie die AWS Lambda-Konsole unter https://console.aws.amazon.com/lambda/.• Eine oder mehrere APIs in API Gateway.

Öffnen Sie die API Gateway-Konsole über https://console.aws.amazon.com/apigateway/.• Eine oder mehrere IAM-Richtlinien oder Rollen in IAM.

Melden Sie sich bei der AWS Management Console an und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

• Eine Instance in Amazon EC2.

Öffnen Sie die Amazon EC2-Konsole unter https://console.aws.amazon.com/ec2/.• Eine oder mehrere Entwicklungsumgebungen in AWS Cloud9.

Für das Anzeigen, den Zugriff und das Verwalten von Entwicklungsumgebungen, öffnen Sie die AWSCloud9-Konsole unter https://console.aws.amazon.com/cloud9/.

Wenn Ihr Projekt mit Ressourcen arbeitet, die außerhalb von AWS liegen (z. B. ein GitHub-Repository oderElemente in Atlassian JIRA), werden diese Ressourcen nicht gelöscht, auch wenn das KontrollkästchenDelete associated AWS resources along with CodeStar project (Löschen der zugeordneten Ressourcenzusammen mit dem AWS CodeStar-Projekt.) aktiviert ist.

149

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

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

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

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

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

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

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

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

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



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

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

AWS CodeStar BenutzerhandbuchTeammanagement-Fehler: Ein IAM-Benutzerkonnte nicht zu einem Team in einem AWS

CodeStar-Projekt hinzugefügt werden.

Teammanagement-Fehler: Ein IAM-Benutzerkonnte nicht zu einem Team in einem AWSCodeStar-Projekt hinzugefügt werden.

Problem: Wenn Sie versuchen, einen Benutzer zu einem Projekt hinzufügen, wird eine Fehlermeldungangezeigt, dass das Hinzufügen fehlgeschlagen ist.

Mögliche Lösungen: Der häufigste Grund für diesen Fehler ist, dass der IAM-Benutzer den Grenzwert fürverwaltete Richtlinien, die auf einen Benutzer in IAM angewendet werden können, erreicht hat. DieserFehler kann auch angezeigt werden, wenn Sie keine Eigentümerrolle im AWS CodeStar-Projekt haben,dem Sie den Benutzer hinzufügen wollten, oder wenn der IAM-Benutzer nicht existiert oder gelöscht wurde.

Stellen Sie sicher, dass Sie als der IAM-Benutzer angemeldet sind, der Eigentümer in diesem AWSCodeStar-Projekt ist. Weitere Informationen finden Sie unter Hinzufügen von Teammitgliedern zu einemAWS CodeStar-Projekt (p. 96).

Öffnen Sie zum Beheben von anderen Problemen die IAM-Konsole, wählen Sie den Benutzer aus, den Siehinzufügen wollten, und prüfen Sie, wie viele verwaltete Richtlinien diesem IAM-Benutzer zugeordnet sind.

Weitere Informationen finden Sie unter Einschränkungen für IAM-Entitäten und -Objekte. Informationen zuEinschränkungen, für die Änderungen möglich sind, finden Sie in den AWS Service Limits.

Zugrifffehler: Ein verbundener Benutzer hat keinenZugriff auf ein AWS CodeStar-Projekt

Problem: Ein verbundener Benutzer kann keine Projekte in der AWS CodeStar Konsole sehen.

Mögliche Lösungen: Wenn Sie als verbundener Benutzer angemeldet sind, stellen Sie sicher, dass Sie dieentsprechende verwaltete Richtlinie an die Rolle angefügt haben, die Sie für die Anmeldung übernehmen.Weitere Informationen finden Sie unter Fügen Sie die verwaltete AWS CodeStar Betrachter/Beitragender/Eigentümer-Richtlinie Ihres Projekts der Rolle des verbundenen Benutzers hinzu. (p. 139).

Fügen Sie verbundene Benutzer zu Ihrer AWS Cloud9-Umgebung hinzu, indem Sie Richtlinien manuellanfügen. Siehe Anfügen einer von AWS Cloud9 verwalteten Richtlinie an die Rolle des verbundenenBenutzers. (p. 140).

Zugrifffehler: Ein verbundener Benutzer kann aufeine AWS Cloud9-Umgebung nicht zugreifen oderdiese erstellen.

Problem: Ein verbundener Benutzer kann eine AWS Cloud9-Umgebung in der AWS Cloud9-Konsole nichtsehen oder erstellen.

Mögliche Lösungen: Wenn Sie als verbundener Benutzer angemeldet sind, stellen Sie sicher, dass Sie dieentsprechende verwaltete Richtlinie an die Rolle des verbundenen Benutzers angefügt haben.

150

https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_iam-limits.html


AWS CodeStar BenutzerhandbuchZugrifffehler: Ein verbundener Benutzer

kann ein AWS CodeStar-Projekt erstellen,aber keine Projektressourcen anzeigen.

Sie fügen verbundene Benutzer zu Ihrer AWS Cloud9-Umgebung hinzu, indem Sie manuell Richtlinienan die Rolle des verbundenen Benutzers anfügen. Siehe Anfügen einer von AWS Cloud9 verwaltetenRichtlinie an die Rolle des verbundenen Benutzers. (p. 140).

Zugrifffehler: Ein verbundener Benutzer kannein AWS CodeStar-Projekt erstellen, aber keineProjektressourcen anzeigen.

Problem: Ein verbundener Benutzer konnte ein Projekt erstellen, kann aber keine Projektressourcenanzeigen, wie z.B. die Projektpipeline.

Mögliche Lösungen: Wenn Sie die verwaltete Richtlinie AWSCodeStarFullAccess angefügthaben, haben Sie die Berechtigung, ein Projekt in AWS CodeStar zu erstellen. Um jedoch auf alleProjektressourcen zugreifen zu können, müssen Sie die verwaltete Richtlinie des Eigentümers anfügen.

Nachdem AWS CodeStar die Projektressourcen erstellt hat, sind die Projektberechtigungen für alleProjektressourcen in den verwalteten Richtlinien Eigentümer, Beitragender und Betrachter verfügbar.Um auf alle Ressourcen zugreifen zu können, müssen Sie Ihrer Rolle manuell die Eigentümerrichtliniezuweisen. Siehe Berechtigungen für verbundene Benutzer konfigurieren (p. 4).

Servicerollen-Problem: Die Servicerolle konnte nichterstellt werden.

Problem: Wenn Sie ein Projekt in AWS CodeStar erstellen möchten, wird eine Nachricht mit derAufforderung angezeigt, dass Sie die Servicerolle erstellen sollen. Wenn Sie die Option zum Erstellenauswählen, wird eine Fehlermeldung angezeigt.

Mögliche Lösungen: Der häufigste Grund für diesen Fehler besteht darin, dass Sie mit einem Kontobei AWS angemeldet sind, das nicht über ausreichende Berechtigungen zum Erstellen der Servicerolleverfügt. Um die AWS CodeStar-Servicerolle (aws-codestar-service-role) zu erstellen, müssenSie als administrativer Benutzer oder mit einem Stammkonto angemeldet sein. Melden Sie sich beider Konsole ab und melden Sie sich dann mit einem IAM-Benutzer erneut an, auf den die verwalteteAdministratorAccess-Richtlinie angewendet wird.

Servicerollen-Problem: Die Servicerolle ist ungültigoder fehlt.

Problem: Wenn Sie die AWS CodeStar-Konsole öffnen, wird eine Meldung angezeigt, dass die AWSCodeStar-Servicerolle fehlt oder ungültig ist.

Mögliche Lösungen: Der häufigste Grund für diesen Fehler ist, dass ein administrativer Benutzer dieServicerolle (aws-codestar-service-role) bearbeitet oder gelöscht hat. Wenn die Servicerollegelöscht wurde, werden Sie aufgefordert, sie zu erstellen. Sie müssen als administrativer Benutzer odermit einem Stammkonto angemeldet sein, um die Rolle zu erstellen. Wenn die Rolle bearbeitet wurde, istsie nicht mehr gültig. Melden Sie sich als administrativer Benutzer bei der IAM-Konsole an, suchen Sie in

151

AWS CodeStar BenutzerhandbuchProjektrollen-Problem: Die AWS Elastic

Beanstalk Zustandsprüfungen schlagen beiInstances in einem AWS CodeStar-Projekt fehl

der Liste der Rollen die Servicerolle und löschen Sie diese. Wechseln Sie zur AWS CodeStar-Konsole undbefolgen Sie die Anweisungen auf dem Bildschirm, um die Servicerolle zu erstellen.

Projektrollen-Problem: Die AWS Elastic BeanstalkZustandsprüfungen schlagen bei Instances in einemAWS CodeStar-Projekt fehl

Problem: Wenn Sie vor dem 22. September 2017 ein AWS CodeStar-Projekt erstellt haben, das ElasticBeanstalk enthält, können die Zustandsprüfungen von Elastic Beanstalk fehlschlagen. Wenn Sie dieElastic Beanstalk-Konfiguration nicht geändert haben, seitdem Sie das Projekt erstellt haben, schlägtdie Zustandsprüfung fehl und meldet einen Grauzustand. Trotz des Fehlers der Zustandsprüfung sollteIhre Anwendung trotzdem wie erwartet laufen. Wenn Sie die Elastic Beanstalk-Konfiguration geänderthaben, seitdem Sie das Projekt erstellt haben, schlägt die Zustandsprüfung fehl, und Ihre Anwendung wirdmöglicherweise nicht korrekt ausgeführt.

Lösung: Bei einer oder mehreren IAM-Rollen fehlen die erforderlichen IAM-Richtlinienanweisungen. FügenSie die fehlenden Richtlinien an die betroffenen Rollen in Ihrem AWS-Konto an.

1. Melden Sie sich bei der AWS Management Console an und öffnen Sie die IAM-Konsole unter https://console.aws.amazon.com/iam/.

(Wenn Sie damit Schwierigkeiten haben, wenden Sie sich an Ihren AWS-Kontoadministrator.)2. Wählen Sie im Navigationsbereich Roles aus.3. Wählen Sie in der Liste der Rollen CodeStarWorker-Projekt-ID-EB, wobei Projekt-ID die ID

eines der betroffenen Projekte ist. (Wenn Sie eine Rolle nicht einfach in der Liste finden können, gebenSie den Namen der Rolle ganz oder teilweise in das Feld Search (Suche) ein.)

4. Wählen Sie auf der Registerkarte Permissions (Berechtigungen) die Option Attach Policy (Richtliniezuweisen) aus.

5. Wählen Sie in der Liste der Richtlinien AWSElasticBeanstalkEnhancedHealth undAWSElasticBeanstalkService aus. (Wenn Sie eine Richtlinie nicht einfach in der Liste finden können,geben Sie den Namen der Richtlinie ganz oder teilweise in das Suchfeld ein.)

6. Wählen Sie Attach Policy (Richtlinie zuweisen) aus.7. Wiederholen Sie die Schritte 3 bis 6 für jede betroffene Rolle, die einen Namen nach dem Muster

CodeStarWorker-Projekt-ID-EB aufweist.

Projektrollen-Problem: Eine Projektrolle ist ungültigoder fehlt.

Problem: Wenn Sie versuchen, einen Benutzer zu einem Projekt hinzufügen, wird eine Fehlermeldungangezeigt, dass das Hinzufügen fehlgeschlagen ist, da die Richtlinie für eine Projektrolle fehlt oder ungültigist.

Mögliche Lösungen: Der häufigste Grund für diesen Fehler ist, dass eine oder mehrere Projektrichtlinienin IAM bearbeitet oder gelöscht wurden. Projektrichtlinien sind eindeutig für AWS CodeStar-Projekte undkönnen nicht neu erstellt werden. Das Projekt kann nicht verwendet werden. Erstellen Sie ein neues Projektin AWS CodeStar und Migrieren Sie dann die Daten in das neue Projekt. Klonen Sie Projektcode aus demRepository des unbrauchbaren Projekts und übertragen Sie diesen Code in das Repository des neuenProjekts. Kopieren Sie Team-Wiki-Informationen aus dem alten Projekt in das neue Projekt. Fügen Sie

152



AWS CodeStar BenutzerhandbuchProjekterweiterungen: Keine Verbindung zu JIRA möglich

Benutzer zum neuen Projekt hinzu. Wenn Sie sicher, dass Sie alle Daten und Einstellungen migriert haben,löschen Sie das unbrauchbare Projekt.

Projekterweiterungen: Keine Verbindung zu JIRAmöglich

Problem: Wenn Sie die Erweiterung "Atlassian JIRA" verwenden, um eine Verbindung zwischen einemAWS CodeStar-Projekt und einer JIRA-Instance herzustellen, wird die folgende Meldung angezeigt: "DieURL ist keine gültige JIRA-URL. Stellen Sie sicher, dass die URL richtig ist.”

Mögliche Lösungen:

• Stellen Sie sicher, dass die JIRA-URL richtig ist, und versuchen Sie dann erneut, eine Verbindungherzustellen.

• Ihre Self-Hosting-JIRA-Instance ist möglicherweise nicht über das öffentliche Internet zugänglich.Wenden Sie sich an Ihren Netzwerkadministrator, um sicherzustellen, dass Ihre JIRA-Instance über dasöffentliche Internet zugänglich ist, und versuchen Sie erneut, eine Verbindung herzustellen.

GitHub: Kein Zugriff auf den Commit-Verlauf einesRepositorys, Probleme oder Code

Problem: Auf dem Dashboard für ein Projekt, das seinen Code in GitHub speichert, zeigen die KachelnCommit history (Commit-Verlauf) und GitHub Issues (GitHub-Probleme) einen Verbindungsfehler an oderbei der Auswahl von Open in GitHub (In GitHub öffnen) oder Create issue (Problem erstellen) in diesenKacheln wird ein Fehler angezeigt.

Mögliche Ursachen:

• Das AWS CodeStar-Projekt hat möglicherweise keinen Zugriff mehr auf das GitHub-Repository.• Das Repository wurde möglicherweise in GitHub gelöscht oder umbenannt.

AWS CloudFormation: Stapelbildung wegenfehlender Berechtigungen zurückgerollt

Nachdem Sie eine Ressource zur Datei template.yml hinzugefügt haben, prüfen Sie das Update desAWS CloudFormation-Stacks auf Fehlermeldungen. Die Stapelaktualisierung schlägt fehl, wenn bestimmteKriterien nicht erfüllt sind (z.B. wenn erforderliche Ressourcenberechtigungen fehlen).

Note

Ab dem 2. Mai 2019 haben wir die AWS CloudFormation-Arbeitskraft-Rollenrichtliniefür alle vorhandenen Projekte aktualisiert. Dieses Update reduziert den Umfang derZugriffsberechtigungen, die Ihrer Projektpipeline gewährt wurden, zur Verbesserung der Sicherheitin Ihren Projekten.

Zeigen Sie zur Fehlerbehebung den Fehlerstatus in der AWS CodeStar Dashboard-Ansicht der Pipeline fürIhr Projekt an.

153

AWS CodeStar BenutzerhandbuchAWS CloudFormation ist nicht für die

Ausführung von „iam:PassRole“ auf derLambda Ausführungsrolle autorisiert.

Wählen Sie dann den Link CloudFormation in der Bereitstellungsstufe Ihrer Pipeline, um den Fehler in derAWS CloudFormation-Konsole zu suchen. Um Details zur Stapelbildung anzuzeigen, erweitern Sie dieListe der Events (Ereignisse) für Ihr Projekt und zeigen Sie alle Fehlermeldungen an. Die Meldung zeigt an,welche Berechtigung fehlt. Korrigieren Sie die AWS CloudFormation-Worker-Rollenrichtlinie und führen SieIhre Pipeline dann erneut aus.

AWS CloudFormation ist nicht für dieAusführung von „iam:PassRole“ auf der LambdaAusführungsrolle autorisiert.

Wenn Sie vor dem 6. Dezember 2018 PDT ein Projekt erstellt haben, mit dem Lambda-Funktionen erstelltwerden, wird möglicherweise ein AWS CloudFormation-Fehler wie dieser angezeigt:

User: arn:aws:sts::id:assumed-role/CodeStarWorker-project-id-CloudFormation/AWSCloudFormation is not authorized to perform: iam:PassRole on resource: arn:aws:iam::id:role/CodeStarWorker-project-id-Lambda (Service: AWSLambdaInternal; Status Code: 403; Error Code: AccessDeniedException; Request ID: id)

Dieser Fehler tritt auf, da die AWS CloudFormation-Worker-Rolle nicht über die Berechtigung zumÜbergeben einer Rolle zur Bereitstellung Ihrer neuen Lambda-Funktion verfügt.

Um diesen Fehler zu beheben, müssen Sie die AWS CloudFormation-Worker-Rollenrichtlinie mit demfolgenden Codeausschnitt aktualisieren.

{ "Action":[ "iam:PassRole" ], "Resource": [ "arn:aws:iam::account-id:role/CodeStarWorker-project-id-Lambda", ], "Effect": "Allow" }

Nachdem Sie die Richtlinie aktualisiert haben, führen Sie Ihre Pipeline erneut aus.

Sie können auch eine benutzerdefinierte Rolle für Ihre Lambda-Funktion verwenden, indem Sie IhremProjekt eine Berechtigungsgrenze zuweisen. Einzelheiten dazu finden Sie unter Vorhandenen Projekteneine IAM-Berechtigungsgrenze hinzufügen (p. 116)

154


AWS CodeStar-BenutzerhandbuchVersionshinweise

In der folgenden Tabelle sind wichtige Änderungen in jeder Version des AWS CodeStar-Benutzerhandbuchs beschrieben. Um Benachrichtigungen über Aktualisierungen dieser Dokumentation zuerhalten, können Sie einen RSS-Feed abonnieren.

update-history-change update-history-description update-history-date

AWS CodeStar-Projekte könnenmit dem AWS CodeStar CLIerstellt werden. (p. 155)

AWS CodeStar Projektekönnen mit dem CLI-Befehlerstellt werden. AWS CodeStarerstellt Ihr Projekt und dieInfrastruktur mit Quellcode undeine Toolchain-Vorlage, die Sieangeben. Siehe Erstellen einesProjekts in AWS CodeStar (AWSCLI).

October 24, 2018

Alle AWS CodeStar-Projektvorlagen enthalten jetztdie AWS CloudFormation-Datei für Infrastruktur-Updates (p. 155)

AWS CodeStar arbeitet mit,AWS CloudFormation, damit SieCode verwenden können, umSupport-Services und Serveroder serverlose Plattformenin der Cloud zu erstellen. DieAWS CloudFormation-Dateiist jetzt verfügbar für alle AWSCodeStar-Projektvorlage-Typen(Vorlagen mit der Lambda,EC2 oder Elastic Beanstalk-Compute-Plattform). Die Dateiist in im Quell-Repository intemplate.yml gespeichert.Sie können die Datei anzeigenund ändern, um Ressourcen zuIhrem Projekt hinzufügen. SieheProjektvorlagen.

August 3, 2018

Aktualisierungsbenachrichtigungenfür das AWS CodeStar-Benutzerhandbuch jetzt überRSS verfügbar (p. 155)

Die HTML-Version des AWSCodeStar-Benutzerhandbuchsunterstützt jetzt einen RSS-Feedfür Aktualisierungen, die auf derSeite Documentation UpdateRelease Notes dokumentiertsind. Der RSS-Feed umfasstAktualisierungen nach dem 30.Juni 2018 und später. Zuvorangekündigte Updates stehennach wie vor auf der Seite

June 30, 2018

155

https://docs.aws.amazon.com/codestar/latest/userguide/how-to-create-project.html#how-to-create-project-cli



https://docs.aws.amazon.com/codestar/latest/userguide/templates.html


Documentation Update ReleaseNotes zur Verfügung. VerwendenSie die RSS-Schaltfläche in deroberen Menüanzeige, um denFeed zu abonnieren.

In der folgenden Tabelle sind die wichtigen Änderungen in jeder Version des AWS CodeStar-Benutzerhandbuchs vor dem 30. Juni 2018 beschrieben.

Änderung Beschreibung Datumgeändert

Das AWS CodeStar-Benutzerhandbuchist jetzt auf GitHubverfügbar

Diese Anleitung ist jetzt auf GitHub verfügbar. Siekönnen GitHub auch verwenden, um Feedback undÄnderungsanforderungen zum Inhalt dieser Anleitung zusenden. Weitere Informationen erhalten Sie, indem Sie dasSymbol Auf GitHub bearbeiten in der Navigationsleiste derAnleitung auswählen oder im awsdocs/aws-codestar-user-guide-Repository auf der GitHub-Website nachsehen.

22. Februar2018

AWS CodeStar istnun in der RegionAsien-Pazifik (Seoul)verfügbar

AWS CodeStar ist jetzt in der Region Asien-Pazifik (Seoul)verfügbar. Weitere Informationen finden Sie unter AWSCodeStar im Allgemeine Amazon Web Services-Referenz.

14. Februar2018

AWS CodeStar istjetzt in den RegionenAsien-Pazifik (Tokio)und Kanada (Zentral)verfügbar

AWS CodeStar ist jetzt in den Regionen Asien-Pazifik (Tokio)und Kanada (Zentral) verfügbar. Weitere Informationenfinden Sie unter AWS CodeStar im Allgemeine Amazon WebServices-Referenz.

20. Dezember2017

AWS CodeStarunterstützt jetzt AWSCloud9

AWS CodeStar unterstützt jetzt die Verwendung von AWSCloud9, einer Web-Browser-basierten Online-IDE, für die Arbeitmit Projekt-Code. Weitere Informationen finden Sie unter AWSCloud9 und AWS CodeStar (p. 57).

Eine Liste der unterstützten AWS-Regionen finden Sie unterAWS Cloud9 im Allgemeine Amazon Web Services-Referenz.

30. November2017

AWS CodeStarunterstützt jetztGitHub

AWS CodeStar unterstützt jetzt das Speichern von Projektcodein GitHub. Weitere Informationen finden Sie unter Ein Projekterstellen (p. 49).

12. Oktober2017

AWS CodeStarist jetzt in denRegionen USA West(Nordkalifornien) undEuropa (London)verfügbar

AWS CodeStar ist jetzt in den Regionen USA West(Nordkalifornien) und Europa (London) verfügbar. WeitereInformationen finden Sie unter AWS CodeStar im AllgemeineAmazon Web Services-Referenz.

17. August2017

AWS CodeStar istjetzt in den RegionenAsien-Pazifik(Sydney), Asien-Pazifik (Singapur) undEuropa (Frankfurt)verfügbar

AWS CodeStar ist jetzt in den Regionen Asien-Pazifik(Sydney), Asien-Pazifik (Singapur) und Europa (Frankfurt)verfügbar. Weitere Informationen finden Sie unter AWSCodeStar im Allgemeine Amazon Web Services-Referenz.

25. Juli 2017

156

https://github.com/awsdocs/aws-codestar-user-guide

https://github.com/awsdocs/aws-codestar-user-guide









Änderung Beschreibung Datumgeändert

AWS CloudTrailunterstützt jetzt AWSCodeStar

AWS CodeStar ist jetzt Bestandteil von CloudTrail, einemService zur Erfassung von API-Aufrufen, die von oder fürAWS CodeStar in Ihrem AWS-Konto durchgeführt werden,und zur Übermittlung der Protokolldateien in einen von Ihnenangegebenen Amazon S3-Bucket. Weitere Informationenfinden Sie unter Protokollieren von AWS CodeStar-API-Aufrufen mit AWS CloudTrail (p. 142).

14. Juni 2017

Erstversion Dies ist die erste Version des AWS CodeStar-Benutzerhandbuchs.

19. April 2017

157


AWS-GlossarDie aktuelle AWS-Terminologie finden Sie im AWS-Glossar im AWS General Reference.

158

https://docs.aws.amazon.com/general/latest/gr/glos-chap.html

AWS CodeStar - Benutzerhandbuch · AWS CodeStar Benutzerhandbuch Schritt 1: Erstellen eines AWS-Kontos Einrichten von AWS CodeStar Bevor Sie AWS CodeStar verwenden können, müssen

Documents