Dans le monde du développement de logiciels, la révision et l'approbation du code sont des processus importants pour garantir la qualité, la sécurité et la fonctionnalité du logiciel en cours de développement. Cependant, les gestionnaires chargés de superviser ces processus critiques sont souvent confrontés à de nombreux défis, tels que les suivants :

• Manque d'expertise technique – Les managers peuvent ne pas avoir une compréhension technique approfondie du langage de programmation utilisé ou ne pas avoir été impliqués dans l’ingénierie logicielle depuis une période prolongée. Cela entraîne un manque de connaissances qui peut rendre difficile l’évaluation précise de l’impact et du bien-fondé des modifications proposées au code.
• Contraintes de temps – La révision et l’approbation du code peuvent être un processus long, en particulier dans les projets plus importants ou plus complexes. Les gestionnaires doivent trouver un équilibre entre la rigueur de l'examen et la pression exercée pour respecter les délais du projet.
• Volume de demandes de changement – Gérer un volume élevé de demandes de changement est un défi courant pour les managers, surtout s'ils supervisent plusieurs équipes et projets. Tout comme le défi de la contrainte de temps, les managers doivent être capables de traiter ces demandes efficacement afin de ne pas freiner l'avancement du projet.
• Effort manuel – La révision du code nécessite un effort manuel de la part des responsables, et le manque d’automatisation peut rendre difficile la mise à l’échelle du processus.
• Documentation – Une documentation appropriée du processus de révision et d’approbation du code est importante pour la transparence et la responsabilité.

Avec la montée de intelligence artificielle générative (IA), les responsables peuvent désormais exploiter cette technologie transformatrice et l'intégrer à la suite d'outils et de services de déploiement AWS pour rationaliser le processus d'examen et d'approbation d'une manière qui n'était pas possible auparavant. Dans cet article, nous explorons une solution qui offre un workflow de déploiement intégré de bout en bout qui intègre une analyse et une synthèse automatisées des modifications ainsi qu'une fonctionnalité de workflow d'approbation. Nous utilisons Socle amazonien, un service entièrement géré qui rend disponibles les modèles de base (FM) des principales startups d'IA et d'Amazon via une API, afin que vous puissiez choisir parmi une large gamme de FM pour trouver le modèle le mieux adapté à votre cas d'utilisation. Avec l'expérience sans serveur Amazon Bedrock, vous pouvez démarrer rapidement, personnaliser les FM en privé avec vos propres données, puis les intégrer et les déployer dans vos applications à l'aide des outils AWS sans avoir à gérer d'infrastructure.

Vue d'ensemble de la solution

Le diagramme suivant illustre l'architecture de la solution.

Le flux de travail comprend les étapes suivantes :

1. Un développeur envoie de nouvelles modifications de code à son référentiel de code (telles que Code AWSCommit), qui déclenche automatiquement le démarrage d'un AWS CodePipeline déploiement.
2. Le code de l'application passe par un processus de création de code, effectue des analyses de vulnérabilité et effectue des tests unitaires à l'aide de vos outils préférés.
3. Création de code AWS récupère le référentiel et exécute une commande git show pour extraire les différences de code entre la version de validation actuelle et la version de validation précédente. Cela produit une sortie ligne par ligne qui indique les modifications de code apportées dans cette version.
4. CodeBuild enregistre la sortie dans un Amazon DynamoDB tableau avec des informations de référence supplémentaires :
   1. ID d'exécution CodePipeline
   2. Région AWS
   3. Nom du pipeline de code
   4. Numéro de build CodeBuild
   5. Date et heure
   6. Statut
5. Flux Amazon DynamoDB capture les modifications des données apporté à la table.
6. An AWS Lambda La fonction est déclenchée par le flux DynamoDB pour traiter l'enregistrement capturé.
7. La fonction invoque le modèle Anthropic Claude v2 sur Amazon Bedrock via Amazon Bedrock API InvokeModel appel. Les différences de code, accompagnées d'une invite, sont fournies en entrée au modèle pour analyse, et un résumé des modifications de code est renvoyé en sortie.
8. La sortie du modèle est enregistrée dans la même table DynamoDB.
9. Le gestionnaire est informé via Service de messagerie simple Amazon (Amazon SES) du résumé des modifications du code et que leur approbation est requise pour le déploiement.
10. Le responsable examine l'e-mail et fournit sa décision (approuver ou rejeter) ainsi que tous les commentaires de révision via la console CodePipeline.
11. La décision d'approbation et les commentaires d'examen sont capturés par Amazon Event Bridge, qui déclenche une fonction Lambda pour les enregistrer à nouveau dans DynamoDB.
12. S'il est approuvé, le pipeline déploie le code de l'application à l'aide de vos outils préférés. En cas de rejet, le flux de travail se termine et le déploiement ne se poursuit pas.

Dans les sections suivantes, vous déployez la solution et vérifiez le flux de travail de bout en bout.

Pré-requis

Pour suivre les instructions de cette solution, vous avez besoin des prérequis suivants :

Déployez la solution

Pour déployer la solution, procédez comme suit :

1. Selectionnez Lancer la pile pour lancer une pile CloudFormation dans us-east-1:
   
2. Pour Adresse e-mail, saisissez une adresse e-mail à laquelle vous avez accès. Le récapitulatif des modifications du code sera envoyé à cette adresse email.
3. Pour ID modèle, laissez par défaut anthropic.claude-v2, qui est le modèle Anthropic Claude v2.

Le déploiement du modèle prendra environ 4 minutes.

4. Lorsque vous recevez un e-mail d'Amazon SES pour vérifier votre adresse e-mail, choisissez le lien fourni pour autoriser votre adresse e-mail.
5. Vous recevrez un e-mail intitulé « Résumé des modifications » pour la validation initiale de l'exemple de référentiel dans CodeCommit.
6. Sur la console AWS CloudFormation, accédez au Sortie de la pile déployée.
7. Copiez la valeur de RepoCloneURL. Vous en avez besoin pour accéder au référentiel d’exemples de code.

Testez la solution

Vous pouvez tester le flux de travail de bout en bout en assumant le rôle de développeur et en apportant certaines modifications au code. Un ensemble d’exemples de codes a été préparé pour vous dans CodeCommit. À accéder au référentiel CodeCommit, entrez les commandes suivantes sur votre IDE :

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

Vous trouverez la structure de répertoire suivante pour un Kit de développement AWS Cloud (AWS CDK) application qui crée une fonction Lambda pour effectuer un tri à bulles sur une chaîne d'entiers. La fonction Lambda est accessible via une URL accessible au public.

.
├── 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

Vous apportez trois modifications aux codes d'application.

1. Pour améliorer la fonction afin de prendre en charge à la fois l'algorithme de tri rapide et l'algorithme de tri à bulles, prenez un paramètre pour permettre la sélection de l'algorithme à utiliser, et renvoyez à la fois l'algorithme utilisé et le tableau trié dans la sortie, remplacez tout le contenu de lambda/index.py avec le code suivant:

# 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. Pour réduire le délai d'expiration de la fonction de 10 minutes à 5 secondes (car nous ne nous attendons pas à ce que la fonction s'exécute plus de quelques secondes), mettez à jour la ligne 47 dans my_sample_project/my_sample_project_stack.py comme suit:

timeout=Duration.seconds(5),

3. Pour restreindre l'appel de la fonction à l'aide d'IAM pour plus de sécurité, mettez à jour la ligne 56 dans my_sample_project/my_sample_project_stack.py comme suit:

auth_type=_lambda.FunctionUrlAuthType.AWS_IAM

4. Appliquez les modifications du code en entrant les commandes suivantes :

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

Cela démarre le flux de travail de déploiement de CodePipeline des étapes 1 à 9, comme indiqué dans la présentation de la solution. Lors de l'appel du modèle Amazon Bedrock, nous avons fourni l'invite suivante :

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.

• Contenu propulsé par le référencement et distribution de relations publiques. Soyez amplifié aujourd'hui.
• PlatoData.Network Ai générative verticale. Autonomisez-vous. Accéder ici.
• PlatoAiStream. Intelligence Web3. Connaissance Amplifiée. Accéder ici.
• PlatonESG. Carbone, Technologie propre, Énergie, Environnement, Solaire, La gestion des déchets. Accéder ici.
• PlatoHealth. Veille biotechnologique et essais cliniques. Accéder ici.
• La source: https://aws.amazon.com/blogs/machine-learning/enhance-code-review-and-approval-efficiency-with-generative-ai-using-amazon-bedrock/