In der Welt der Softwareentwicklung sind Codeüberprüfung und -genehmigung wichtige Prozesse zur Gewährleistung der Qualität, Sicherheit und Funktionalität der zu entwickelnden Software. Allerdings stehen Manager, die mit der Überwachung dieser kritischen Prozesse betraut sind, oft vor zahlreichen Herausforderungen, wie zum Beispiel den folgenden:

• Fehlendes technisches Know-how – Führungskräfte verfügen möglicherweise nicht über umfassende technische Kenntnisse der verwendeten Programmiersprache oder waren nicht über einen längeren Zeitraum mit der Softwareentwicklung befasst. Dies führt zu einer Wissenslücke, die es für sie schwierig machen kann, die Auswirkungen und die Solidität der vorgeschlagenen Codeänderungen genau einzuschätzen.
• Zeitbeschränkungen – Die Codeüberprüfung und -genehmigung kann ein zeitaufwändiger Prozess sein, insbesondere bei größeren oder komplexeren Projekten. Manager müssen ein Gleichgewicht zwischen der Gründlichkeit der Überprüfung und dem Druck, Projektzeitpläne einzuhalten, finden.
• Umfang der Änderungswünsche – Der Umgang mit einer großen Menge an Änderungsanfragen stellt für Manager eine häufige Herausforderung dar, insbesondere wenn sie mehrere Teams und Projekte beaufsichtigen. Ähnlich wie bei Zeitbeschränkungen müssen Manager in der Lage sein, diese Anfragen effizient zu bearbeiten, um den Projektfortschritt nicht zu behindern.
• Manueller Aufwand – Die Codeüberprüfung erfordert manuellen Aufwand durch die Manager, und die mangelnde Automatisierung kann die Skalierung des Prozesses erschweren.
• Dokumentation – Eine ordnungsgemäße Dokumentation des Codeüberprüfungs- und Genehmigungsprozesses ist wichtig für Transparenz und Rechenschaftspflicht.

Mit dem Aufstieg von Generative künstliche Intelligenz (KI) können Manager nun diese transformative Technologie nutzen und sie in die AWS-Suite von Bereitstellungstools und -diensten integrieren, um den Überprüfungs- und Genehmigungsprozess auf eine bisher nicht mögliche Weise zu rationalisieren. In diesem Beitrag untersuchen wir eine Lösung, die einen integrierten End-to-End-Bereitstellungsworkflow bietet, der eine automatisierte Änderungsanalyse und -zusammenfassung sowie Genehmigungsworkflow-Funktionen umfasst. Wir gebrauchen Amazonas Grundgestein, ein vollständig verwalteter Dienst, der Stiftungsmodelle (FMs) von führenden KI-Startups und Amazon über eine API verfügbar macht, sodass Sie aus einer breiten Palette von FMs auswählen können, um das Modell zu finden, das für Ihren Anwendungsfall am besten geeignet ist. Mit der serverlosen Erfahrung von Amazon Bedrock können Sie schnell loslegen, FMs privat mit Ihren eigenen Daten anpassen und sie mithilfe von AWS-Tools in Ihre Anwendungen integrieren und bereitstellen, ohne eine Infrastruktur verwalten zu müssen.

Lösungsüberblick

Das folgende Diagramm zeigt die Lösungsarchitektur.

Der Arbeitsablauf besteht aus den folgenden Schritten:

1. Ein Entwickler überträgt neue Codeänderungen in sein Code-Repository (z. B AWS-CodeCommit), was automatisch den Start einer auslöst AWS CodePipeline Einsatz.
2. Der Anwendungscode durchläuft einen Codeerstellungsprozess, führt Schwachstellenscans durch und führt Komponententests mit Ihren bevorzugten Tools durch.
3. AWS CodeBuild ruft das Repository ab und führt einen Git-Show-Befehl aus, um die Codeunterschiede zwischen der aktuellen Commit-Version und der vorherigen Commit-Version zu extrahieren. Dadurch wird eine zeilenweise Ausgabe erstellt, die die in dieser Version vorgenommenen Codeänderungen angibt.
4. CodeBuild speichert die Ausgabe in einem Amazon DynamoDB Tabelle mit zusätzlichen Referenzinformationen:
   1. CodePipeline-Ausführungs-ID
   2. AWS-Region
   3. CodePipeline-Name
   4. CodeBuild-Build-Nummer
   5. Datum und Uhrzeit
   6. Status
5. Amazon DynamoDB-Streams erfasst die Datenänderungen an den Tisch gebracht.
6. An AWS Lambda Die Funktion wird vom DynamoDB-Stream ausgelöst, um den erfassten Datensatz zu verarbeiten.
7. Die Funktion ruft das Anthropic Claude v2-Modell auf Amazon Bedrock über Amazon Bedrock auf InvokeModel-API Anruf. Die Codeunterschiede werden zusammen mit einer Eingabeaufforderung als Eingabe für die Analyse des Modells bereitgestellt und eine Zusammenfassung der Codeänderungen wird als Ausgabe zurückgegeben.
8. Die Ausgabe des Modells wird wieder in derselben DynamoDB-Tabelle gespeichert.
9. Der Manager wird über benachrichtigt Einfacher Amazon-E-Mail-Dienst (Amazon SES) der Zusammenfassung der Codeänderungen und dass für die Bereitstellung deren Genehmigung erforderlich ist.
10. Der Manager überprüft die E-Mail und gibt seine Entscheidung (entweder genehmigen oder ablehnen) zusammen mit etwaigen Überprüfungskommentaren über die CodePipeline-Konsole bekannt.
11. Die Genehmigungsentscheidung und die Überprüfungskommentare werden von erfasst Amazon EventBridge, was eine Lambda-Funktion auslöst, um sie wieder in DynamoDB zu speichern.
12. Bei Genehmigung stellt die Pipeline den Anwendungscode mit Ihren bevorzugten Tools bereit. Bei Ablehnung endet der Workflow und die Bereitstellung wird nicht fortgesetzt.

In den folgenden Abschnitten stellen Sie die Lösung bereit und überprüfen den End-to-End-Workflow.

Voraussetzungen:

Um den Anweisungen in dieser Lösung folgen zu können, benötigen Sie die folgenden Voraussetzungen:

Stellen Sie die Lösung bereit

Führen Sie die folgenden Schritte aus, um die Lösung bereitzustellen:

1. Auswählen Stack starten um einen CloudFormation-Stack zu starten us-east-1:
   
2. Aussichten für E-Mail-AddresseGeben Sie eine E-Mail-Adresse ein, auf die Sie Zugriff haben. Die Zusammenfassung der Codeänderungen wird an diese E-Mail-Adresse gesendet.
3. Aussichten für Modell-ID, belassen Sie die Standardeinstellung anthropic.claude-v2, das Anthropic Claude v2-Modell.

Die Bereitstellung der Vorlage dauert etwa 4 Minuten.

4. Wenn Sie eine E-Mail von Amazon SES zur Bestätigung Ihrer E-Mail-Adresse erhalten, wählen Sie den bereitgestellten Link aus, um Ihre E-Mail-Adresse zu autorisieren.
5. Sie erhalten eine E-Mail mit dem Titel „Zusammenfassung der Änderungen“ für den ersten Commit des Beispiel-Repositorys in CodeCommit.
6. Navigieren Sie in der AWS CloudFormation-Konsole zum Ausgänge Registerkarte des bereitgestellten Stapels.
7. Kopieren Sie den Wert von RepoCloneURL. Sie benötigen dies, um auf das Beispielcode-Repository zuzugreifen.

Testen Sie die Lösung

Sie können den Workflow durchgängig testen, indem Sie die Rolle eines Entwicklers übernehmen und einige Codeänderungen vorantreiben. In CodeCommit wurde eine Reihe von Beispielcodes für Sie vorbereitet. Zu Greifen Sie auf das CodeCommit-Repository zuGeben Sie die folgenden Befehle in Ihrer IDE ein:

git clone <replace_with_value_of_RepoCloneURL>
cd my-sample-project
ls

Sie finden die folgende Verzeichnisstruktur für ein AWS Cloud-Entwicklungskit (AWS CDK)-Anwendung, die eine Lambda-Funktion erstellt, um eine Blasensortierung für eine Zeichenfolge von Ganzzahlen durchzuführen. Die Lambda-Funktion ist über eine öffentlich zugängliche URL zugänglich.

.
├── README.md
├── app.py
├── cdk.json
├── lambda
│ └── index.py
├── my_sample_project
│ ├── __init__.py
│ └── my_sample_project_stack.py
├── requirements-dev.txt
├── requirements.txt
└── source.bat

Sie nehmen drei Änderungen an den Anwendungscodes vor.

1. Um die Funktion so zu erweitern, dass sie sowohl den Schnellsortierungs- als auch den Blasensortierungsalgorithmus unterstützt, nehmen Sie einen Parameter auf, der die Auswahl des zu verwendenden Algorithmus ermöglicht, geben Sie sowohl den verwendeten Algorithmus als auch das sortierte Array in der Ausgabe zurück und ersetzen Sie den gesamten Inhalt von lambda/index.py mit folgendem Code:

# function to perform bubble sort on an array of integers
def bubble_sort(arr):
    for i in range(len(arr)):
        for j in range(len(arr)-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# function to perform quick sort on an array of integers
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        less = [i for i in arr[1:] if i <= pivot]
        greater = [i for i in arr[1:] if i > pivot]
        return quick_sort(less) + [pivot] + quick_sort(greater)

# lambda handler
def lambda_handler(event, context):
    try:
        algorithm = event['queryStringParameters']['algorithm']
        numbers = event['queryStringParameters']['numbers']
        arr = [int(x) for x in numbers.split(',')]
        if ( algorithm == 'bubble'):
            arr = bubble_sort(arr)
        elif ( algorithm == 'quick'):
            arr = quick_sort(arr)
        else:
            arr = bubble_sort(arr)

        return {
            'statusCode': 200,
            'body': {
                'algorithm': algorithm,
                'numbers': arr
            }
        }
    except:
        return {
            'statusCode': 200,
            'body': {
                'algorithm': 'bubble or quick',
                'numbers': 'integer separated by commas'
            }
        }

2. Um die Timeout-Einstellung der Funktion von 10 Minuten auf 5 Sekunden zu reduzieren (da wir nicht erwarten, dass die Funktion länger als ein paar Sekunden läuft), aktualisieren Sie Zeile 47 in my_sample_project/my_sample_project_stack.py wie folgt:

timeout=Duration.seconds(5),

3. Um den Aufruf der Funktion mithilfe von IAM für zusätzliche Sicherheit einzuschränken, aktualisieren Sie Zeile 56 in my_sample_project/my_sample_project_stack.py wie folgt:

auth_type=_lambda.FunctionUrlAuthType.AWS_IAM

4. Drücken Sie die Codeänderungen, indem Sie die folgenden Befehle eingeben:

git commit -am 'added new changes for release v1.1'
git push

Dadurch wird der CodePipeline-Bereitstellungsworkflow mit den Schritten 1–9 gestartet, wie in der Lösungsübersicht beschrieben. Beim Aufrufen des Amazon Bedrock-Modells haben wir die folgende Eingabeaufforderung bereitgestellt:

Human: Review the following "git show" output enclosed within <gitshow> tags detailing code changes, and analyze their implications.
Assess the code changes made and provide a concise summary of the modifications as well as the potential consequences they might have on the code's functionality.
<gitshow>
{code_change}
</gitshow>

Assistant:

Based on the diff, the following main changes were made:

1. Two sorting algorithms were added - bubble sort and quick sort.
2. The lambda handler was updated to take an 'algorithm' query parameter to determine which sorting algorithm to use. By default it uses bubble sort if no algorithm is specified. 
3. The lambda handler now returns the sorting algorithm used along with the sorted numbers in the response body.
4. The lambda timeout was reduced from 10 mins to 5 seconds. 
5. The function URL authentication was changed from none to AWS IAM, so only authenticated users can invoke the URL.

Overall, this adds support for different sorting algorithms, returns more metadata in the response, reduces timeout duration, and tightens security around URL access. The main functional change is the addition of the sorting algorithms, which provides more flexibility in how the numbers are sorted. The other changes improve various non-functional attributes of the lambda function.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://aws.amazon.com/blogs/machine-learning/enhance-code-review-and-approval-efficiency-with-generative-ai-using-amazon-bedrock/