Tutorial: creazione di un'applicazione completa con blueprint componibili PDK

1. Apri la CodeCatalyst console all'indirizzo https://codecatalyst.aws/.

2. Nella CodeCatalyst console, accedi allo spazio in cui desideri creare un progetto.

3. Nella dashboard dello spazio, scegli Crea progetto.

4. Scegli Inizia con un progetto.

5. Scegli il blueprint PDK- Monorepo, quindi scegli Avanti.

6. In Assegna un nome al progetto, inserisci il nome che desideri assegnare al progetto e i nomi delle risorse associate. Il nome deve essere univoco all'interno del tuo spazio.

7. In Risorse del progetto, procedi come segue:

   1. In Linguaggio di programmazione principale, scegli il linguaggio in cui desideri sviluppare il codice del progetto. Puoi scegliere TypeScript tra Java o Python.

   2. Scegli Code Configuration

   3. Nel campo di immissione del testo Source Repository, inserisci il nome di un repository di origine, che creerà un nuovo repository, oppure selezionalo da un repository collegato esistente. Il repository esistente deve essere vuoto. Per ulteriori informazioni, consulta Collegamento di un repository di sorgenti.

   4. (Facoltativo) Dal menu a discesa Package Manager, scegli un gestore di pacchetti. Questo è necessario solo se è stato selezionato TypeScript come linguaggio di programmazione principale.

8. (Facoltativo) Per visualizzare in anteprima il codice che verrà generato in base alle selezioni dei parametri di progetto effettuate, scegliete Visualizza codice da Genera anteprima del progetto.

9. (Facoltativo) Scegli Visualizza dettagli dalla scheda del progetto per visualizzare dettagli specifici sul progetto, come una panoramica dell'architettura del progetto, le connessioni e le autorizzazioni richieste e il tipo di risorse create dal blueprint.

10. Scegli Crea progetto per creare il tuo progetto monorepo. Il progetto a livello di root creato gestisce le interdipendenze tra i progetti all'interno del monorepo, oltre a fornire la memorizzazione nella cache delle build e la gestione delle dipendenze.

    Per ulteriori informazioni sui progetti, vedere. Creazione di un progetto completo con CodeCatalyst progetti

1. Nel pannello di navigazione del tuo progetto monorepo, scegli Blueprints, quindi scegli Aggiungi blueprint.

2. Scegli il API blueprint PDK- Type Safe, quindi scegli Avanti.

3. In Configura blueprint, configura i parametri del blueprint:

   • In Model Language, scegli la lingua in cui è definito il API modello.

   • Nel campo di immissione del testo Namespace, inserisci uno spazio dei nomi per il tuo. API

   • Nel campo di immissione del testo del APInome, inserisci un nome per il tuo. API

   • In CDKlingua, scegli la lingua preferita per scrivere l'CDKinfrastruttura API in cui implementare l'infrastruttura.

   • Scegli il menu a discesa Handler language (s), quindi scegli le lingue in cui desideri implementare i gestori per le operazioni. API

   • Scegli il menu a discesa Formati di documentazione, quindi scegli i formati che desideri per generare la documentazione. API

4. Nella scheda Modifiche al codice, esamina le modifiche proposte. La differenza visualizzata in una pull request mostra le modifiche al progetto al momento della creazione della pull request.

5. Quando sei soddisfatto delle modifiche proposte che verranno apportate quando il blueprint verrà applicato, scegli Aggiungi blueprint.

   Dopo aver creato una pull request, puoi aggiungere commenti. I commenti possono essere aggiunti alla pull request o alle singole righe dei file, nonché alla pull request complessiva. È possibile aggiungere collegamenti a risorse come i file utilizzando il @ segno, seguito dal nome del file.

   Nota

   Il blueprint non verrà applicato finché la pull request non sarà approvata e unita. Per ulteriori informazioni, consulta Revisione di una pull request e Unire una pull request.

6. Dalla colonna Status, scegli Pending pull request per la riga PDK- Type Safe API blueprint, quindi scegli il link della pull request aperta.

7. Scegli Merge, scegli la tua strategia di unione preferita, quindi scegli Merge per incorporare le modifiche dal blueprint applicato.

   Dopo l'unione della pull request, viene generata una nuova packages/apis/mypdkapi cartella all'interno del progetto monorepo, che contiene tutto il codice sorgente API correlato per il Type Safe configurato. API

8. Nel pannello di navigazione, scegli Blueprints per confermare che lo stato di PDK- Type Safe sia aggiornatoAPI.

1. Nel pannello di navigazione del tuo progetto monorepo, scegli Blueprints, quindi scegli Aggiungi blueprint.

2. Scegli il blueprint PDK- Cloudscape React Website, quindi scegli Avanti.

3. In Configura blueprint, configura i parametri del blueprint:

   • Nel campo di immissione del testo del nome del sito Web, inserisci un nome per il tuo sito Web.

   • Scegli il menu a APIs discesa Type Safe, quindi scegli i API progetti che desideri integrare nel sito web. Passando e configurando i client autenticati, API vengono aggiunte le dipendenze necessarie, API Explorer e altre funzionalità.

4. Nella scheda Modifiche al codice, esamina le modifiche proposte. La differenza visualizzata in una pull request mostra le modifiche al progetto al momento della creazione della pull request.

5. Quando sei soddisfatto delle modifiche proposte che verranno apportate quando il blueprint verrà applicato, scegli Aggiungi blueprint.

   Dopo aver creato una pull request, puoi aggiungere commenti. I commenti possono essere aggiunti alla pull request o alle singole righe dei file, nonché alla pull request complessiva. È possibile aggiungere collegamenti a risorse come i file utilizzando il @ segno, seguito dal nome del file.

   Nota

   Il blueprint non verrà applicato finché la pull request non sarà approvata e unita. Per ulteriori informazioni, consulta Revisione di una pull request e Unire una pull request.

6. Dalla colonna Status, scegli Pending pull request per la riga del blueprint PDK- Cloudscape React Website, quindi scegli il link della pull request aperta.

7. Scegli Merge, scegli la tua strategia di unione preferita, quindi scegli Merge per incorporare le modifiche dal blueprint applicato.

   Dopo l'unione della pull request, viene generata una nuova packages/websites/my-website-name cartella all'interno del progetto monorepo, che contiene tutto il codice sorgente del nuovo sito web.

8. Nel pannello di navigazione, scegli Blueprints per confermare che lo stato del sito Web PDK- Cloudscape React sia aggiornato.

1. Nel pannello di navigazione del tuo progetto monorepo, scegli Blueprints, quindi scegli Aggiungi blueprint.

2. Scegli il blueprint PDK- Infrastructure, quindi scegli Avanti.

3. In Configura blueprint, configura i parametri del blueprint:

   • In CDKlingua, scegli la lingua con cui vuoi sviluppare la tua infrastruttura.

   • Nel campo di immissione del testo del nome dello stack, inserisci il nome dello CloudFormation stack generato per il tuo blueprint.

     Nota

     Prendi nota del nome di questo stack per il passaggio successivo, in cui imposterai un flusso di lavoro. DevOps

   • Scegli il menu a APIs discesa Type Safe, quindi scegli i API progetti che desideri integrare nel sito web.

   • Scegli il menu a discesa Siti Web di Cloudscape React TS, quindi scegli i progetti di siti Web che desideri implementare all'interno della tua infrastruttura (ad esempio, - Sito Web Cloudscape React). PDK

4. Nella scheda Modifiche al codice, esamina le modifiche proposte. La differenza visualizzata in una pull request mostra le modifiche al progetto al momento della creazione della pull request.

5. Quando sei soddisfatto delle modifiche proposte che verranno apportate quando il blueprint verrà applicato, scegli Aggiungi blueprint.

   Dopo aver creato una pull request, puoi aggiungere commenti. I commenti possono essere aggiunti alla pull request o alle singole righe dei file, nonché alla pull request complessiva. È possibile aggiungere collegamenti a risorse come i file utilizzando il @ segno, seguito dal nome del file.

   Nota

   Il blueprint non verrà applicato finché la pull request non sarà approvata e unita. Per ulteriori informazioni, consulta Revisione di una pull request e Unire una pull request.

6. Dalla colonna Stato, scegli Pending pull request per la riga PDK- Infrastructure blueprint, quindi scegli il link della pull request aperta.

7. Scegli Merge, scegli la tua strategia di unione preferita, quindi scegli Merge per incorporare le modifiche dal blueprint applicato.

   Dopo l'unione della pull request, viene generata una nuova packages/infra cartella all'interno del progetto monorepo, che contiene l'infrastruttura che implementerà il progetto nel cloud. AWS

8. Nel pannello di navigazione, scegli Blueprints per confermare che lo stato di PDK- Infrastruttura risulti Aggiornato.

1. Nel pannello di navigazione del tuo progetto monorepo, scegli Blueprints, quindi scegli Aggiungi blueprint.

2. Scegli il DevOps progetto PDK-, quindi scegli Avanti.

3. In Configura blueprint, configura i parametri del blueprint:

   • Scegli Bootstrap CDK nell'ambiente corrente.

   • Nel campo di immissione del testo del nome dello stack, inserisci il nome dello CloudFormation stack che desideri distribuire. Questo deve corrispondere al nome dello stack configurato nel blueprint - Fase 4: Generare l'infrastruttura per distribuire l'applicazione nel cloud AWS Infrastructure. PDK

   • Scegli il menu a discesa di connessione all'AWSaccount, quindi scegli l'AWSaccount che desideri utilizzare per le risorse. Per ulteriori informazioni, consulta Aggiungere un Account AWS a uno spazio.

   • Scegli il ruolo da utilizzare per la distribuzione dell'applicazione dal menu a discesa, quindi scegli il IAM ruolo che desideri utilizzare per la distribuzione dell'applicazione di progetto.

     Nota

     Quando crei un IAM ruolo, limitalo SourceArn a quello corrente che ProjectID si trova nelle impostazioni del progetto. Per ulteriori informazioni, consulta Comprensione del ruolo CodeCatalystWorkflowDevelopmentRole-spaceNamedel servizio.

   • Scegli il menu a discesa Regione, quindi scegli la regione in cui desideri implementare il tuo progetto monorepo. La distribuzione funziona solo nelle regioni in cui esistono i servizi richiesti. AWS Per ulteriori informazioni, consulta AWSServizi per regione.

4. Nella scheda Modifiche al codice, esamina le modifiche proposte. La differenza visualizzata in una pull request mostra le modifiche al progetto al momento della creazione della pull request.

5. Quando sei soddisfatto delle modifiche proposte che verranno apportate quando il blueprint verrà applicato, scegli Aggiungi blueprint.

   Dopo aver creato una pull request, puoi aggiungere commenti. I commenti possono essere aggiunti alla pull request o alle singole righe dei file, nonché alla pull request complessiva. È possibile aggiungere collegamenti a risorse come i file utilizzando il @ segno, seguito dal nome del file.

   Nota

   Il blueprint non verrà applicato finché la pull request non sarà approvata e unita. Per ulteriori informazioni, consulta Revisione di una pull request e Unire una pull request.

6. Dalla colonna Stato, scegli Pending pull request per la riga PDK- Infrastructure blueprint, quindi scegli il link della pull request aperta.

7. Scegli Merge, scegli la tua strategia di unione preferita, quindi scegli Merge per incorporare le modifiche dal blueprint applicato.

   Dopo l'unione della pull request, viene generata una nuova .codecatalyst/workflows cartella all'interno del progetto monorepo.

8. Nel pannello di navigazione, scegli Blueprints per confermare che lo stato di PDK- sia DevOps visualizzato Aggiornato.

1. Nel pannello di navigazione del tuo progetto monorepo, scegli CI/CD, quindi scegli Flussi di lavoro.

2. Per il flusso di lavoro di rilascio, scegli il flusso di lavoro più recente eseguito per visualizzare i dettagli. Per ulteriori informazioni, consulta Visualizzazione dello stato e dei dettagli di una singola esecuzione.

3. Una volta completata correttamente l'esecuzione del flusso di lavoro, scegli l'ultima azione del flusso di lavoro (ad esempio, Deploy-B eta-ap-souteast -2), quindi scegli Variabili.

   

4. Visualizza il sito Web distribuito copiando e incollando il collegamento che si trova nella tabella Variabili (ad esempio, MyPDKApiwebsiteDistributionDomainNome XXXXX) in una nuova finestra del browser.

   

   È necessario un account Amazon Cognito per accedere al tuo sito Web. Per impostazione predefinita, il pool di utenti non è configurato per consentire l'autoregistrazione.

   1. Passa alla console AWSCognito.

   2. Dalla tabella User pool, scegli il nome del pool di utenti che corrisponde al pool di utenti creato dal DevOps blueprint PDK-, che si trova nella tabella Variabili (ad esempio, infra calculatebetaUserIdentityinfracalculatebetaUserIdentityIdentityPoolIdXXXXX. Per ulteriori informazioni, consulta Guida introduttiva ai pool di utenti.

      

   3. Selezionare Create user (Crea utente).

   4. Configura i parametri delle informazioni sull'utente:

      • In Messaggio di invito, scegli Invia un invito via e-mail.

      • Nel campo di immissione del testo Nome utente, inserisci un nome utente.

      • Nel campo di immissione del testo dell'indirizzo e-mail, inserisci un nome utente.

      • In Password temporanea, scegli Genera una password.

   5. Selezionare Create user (Crea utente).

   6. Vai all'account e-mail che hai inserito per i parametri delle informazioni utente, apri un'e-mail con una password temporanea. Prendi nota della password.

   7. Torna al sito Web distribuito, inserisci il nome utente che hai creato e la password temporanea che hai ricevuto, quindi scegli Accedi.

5. (Facoltativo) Una volta completata correttamente l'esecuzione del flusso di lavoro, puoi anche visualizzare il diagramma generato. Scegliete la scheda Artefatti in CodeCatalyst, scegliete Scarica per la riga Diagramma, quindi aprite i file scaricati.

   
   

Per invitare un membro al progetto dalla scheda Impostazioni del progetto

1. Vai al tuo progetto.

   Suggerimento

   Puoi scegliere quale progetto visualizzare nella barra di navigazione in alto.

2. Nel riquadro di navigazione, scegli Impostazioni del progetto.

3. Scegli la scheda Membri.

4. In Membri del progetto, scegli Invita nuovo membro.

5. Digita l'indirizzo email del nuovo membro, scegli il ruolo per questo membro, quindi scegli Invita. Per ulteriori informazioni sui ruoli, consulta Concessione dell'accesso con ruoli utente.

Per invitare un membro al tuo progetto dalla pagina di panoramica del progetto

1. Vai al tuo progetto.

   Suggerimento

   Puoi scegliere quale progetto visualizzare nella barra di navigazione in alto.

2. Scegli il pulsante Membri +.

3. Digita l'indirizzo email del nuovo membro, scegli il ruolo per questo membro, quindi scegli Invita. Per ulteriori informazioni sui ruoli, consulta Concessione dell'accesso con ruoli utente.

1. Apri la CodeCatalyst console all'indirizzo https://codecatalyst.aws/.

2. Vai al progetto monorepo in cui desideri creare un problema.

3. Nella home page del progetto, scegli Crea problema. In alternativa, nel riquadro di navigazione, scegli Problemi.

4. Scegli Crea problema.

   Nota

   Puoi anche aggiungere problemi in linea quando usi una visualizzazione a griglia.

5. Inserisci un titolo per il problema.

6. (Facoltativo) Inserisci una descrizione. Per questo problema, inserisci la seguente descrizione:a change in the src/mysfit_data.json file.. Puoi usare Markdown per aggiungere formattazione.

7. (Facoltativo) Scegli uno stato, una priorità e una stima per il problema.

8. (Facoltativo) Aggiungi un'etichetta esistente o crea una nuova etichetta e aggiungila scegliendo + Aggiungi etichetta.

   1. Per aggiungere un'etichetta esistente, scegli l'etichetta dall'elenco. Puoi inserire un termine di ricerca nel campo per cercare tutte le etichette che contengono quel termine nel progetto.

   2. Per creare una nuova etichetta e aggiungerla, inserisci il nome dell'etichetta che desideri creare nel campo di ricerca e premi invio.

9. (Facoltativo) Aggiungi un assegnatario selezionando + Aggiungi un assegnatario. Puoi aggiungerti rapidamente come assegnatario selezionando + Aggiungimi.

   Suggerimento

   Puoi scegliere di assegnare un problema ad Amazon Q per fare in modo che Amazon Q provi a risolverlo. Per ulteriori informazioni, consulta Tutorial: Utilizzo delle funzionalità di intelligenza artificiale CodeCatalyst generativa per velocizzare il lavoro di sviluppo.

   Questa funzionalità richiede che le funzionalità di intelligenza artificiale generativa siano abilitate per lo spazio. Per ulteriori informazioni, consulta Gestione delle funzionalità di intelligenza artificiale generativa.

10. (Facoltativo) Aggiungi un campo personalizzato esistente o crea un nuovo campo personalizzato. I problemi possono avere più campi personalizzati.

    1. Per aggiungere un campo personalizzato esistente, scegli il campo personalizzato dall'elenco. Puoi inserire un termine di ricerca nel campo per cercare tutti i campi personalizzati contenenti quel termine nel progetto.

    2. Per creare un nuovo campo personalizzato e aggiungerlo, inserisci il nome del campo personalizzato che desideri creare nel campo di ricerca e premi invio. Quindi scegli il tipo di campo personalizzato che desideri creare e imposta un valore.

11. Scegli Crea problema. Nell'angolo in basso a destra viene visualizzata una notifica: se il problema è stato creato correttamente, viene visualizzato un messaggio di conferma che indica che il problema è stato creato correttamente. Se il problema non è stato creato correttamente, viene visualizzato un messaggio di errore con il motivo dell'errore. Puoi quindi scegliere Riprova per modificare e riprova a creare il problema oppure scegliere Ignora per eliminare il problema. Entrambe le opzioni annulleranno la notifica.

    Nota

    Non puoi collegare una pull request a un problema al momento della creazione. Tuttavia, puoi modificarla dopo averla creata per aggiungere link alle richieste pull.

Per accedere ai repository di origine di un progetto

1. Accedete al progetto ed effettuate una delle seguenti operazioni:

   • Nella pagina di riepilogo del progetto, scegli il repository desiderato dall'elenco, quindi scegli Visualizza archivio.

   • Nel riquadro di navigazione, scegli Codice, quindi scegli Archivi di origine. Nei repository di origine, scegli il nome del repository dall'elenco. È possibile filtrare l'elenco dei repository digitando parte del nome del repository nella barra dei filtri.

2. Nella home page del repository, visualizza il contenuto del repository e le informazioni sulle risorse associate, come il numero di richieste pull e i flussi di lavoro. Per impostazione predefinita, vengono visualizzati i contenuti del ramo predefinito. È possibile modificare la visualizzazione scegliendo un ramo diverso dall'elenco a discesa.

1. Nel pannello di navigazione del tuo progetto monorepo, esegui una delle seguenti operazioni:

   • Scegli Panoramica, quindi vai alla sezione I miei ambienti di sviluppo.

   • Scegli Code, quindi scegli Dev Environments.

   • Scegli Code, scegli Repository di origine, quindi scegli il repository monorepo per il quale desideri creare un ambiente di sviluppo.

2. Scegli un file supportato IDE dal menu a discesa. Per ulteriori informazioni, consulta Ambienti di sviluppo integrati supportati per gli ambienti di sviluppo.

3. Scegli Clona un repository.

4. Scegli il repository da clonare, scegli Lavora in un nuovo ramo, inserisci il nome di un ramo nel campo Nome del ramo e scegli un ramo dal quale creare il nuovo ramo dal menu a discesa Crea ramo da.

   Nota

   Se crei un ambiente di sviluppo dalla pagina dei repository di origine o da un repository di origine specifico, non è necessario scegliere un repository. L'ambiente di sviluppo verrà creato dal repository di origine che hai scelto nella pagina dei repository di origine.

5. (Facoltativo) In Alias: facoltativo, inserisci un alias per l'ambiente di sviluppo.

6. (Facoltativo) Scegliete il pulsante di modifica della configurazione dell'ambiente di sviluppo per modificare la configurazione di calcolo, archiviazione o timeout dell'ambiente di sviluppo.

7. (Facoltativo) In Amazon Virtual Private Cloud (AmazonVPC): facoltativo, seleziona una VPC connessione che desideri associare al tuo ambiente di sviluppo dal menu a discesa.

   Se VPC è impostato un valore predefinito per il tuo spazio, i tuoi ambienti di sviluppo verranno eseguiti collegati a quello. VPC Puoi sovrascriverlo associando una connessione diversaVPC. Inoltre, tieni presente che gli ambienti VPC di sviluppo connessi non supportano Toolkit. AWS

   Nota

   Quando si crea un ambiente di sviluppo con una VPC connessione, viene creata una nuova interfaccia di rete all'interno di. VPC CodeCatalyst interagisce con questa interfaccia utilizzando il VPC ruolo associato. Inoltre, assicurati che il IPv4 CIDR blocco non sia configurato nell'intervallo di indirizzi 172.16.0.0/12 IP.

8. Scegli Create (Crea) . Durante la creazione del tuo ambiente di sviluppo, la colonna di stato dell'ambiente di sviluppo mostrerà Avvio e la colonna di stato mostrerà In esecuzione una volta creato l'ambiente di sviluppo.

1. In un terminale funzionante del tuo ambiente di sviluppo, accedi al tuo progetto monorepo, quindi installa le dipendenze del progetto eseguendo il seguente comando:

   npx projen install

2. Passa apackages/apis/mypdkapi/model/src/main/smithy/operations/say-hello.smithy, che definisce un'operazione di esempio. API In questo tutorial, creerai una semplice Calculate operazione che somma due numeri. Apporta una modifica al codice per definire questa operazione, inclusi i relativi input e output.

   Esempio:

   $version: "2"
   namespace com.aws
   
   @http(method: "POST", uri: "/calculate")
   @handler(language: "typescript")
   operation Calculate {
       input := {
           @required
           numberA: Integer
           @required
           numberB: Integer
       }
       output := {
           @required
           result: Integer
       }
   }

   La @handler caratteristica dice a Type Safe API che implementerai questa operazione come gestore AWS Lambda scritto. TypeScript Type Safe API genererà uno stub per questa operazione in cui potrai implementarla. TypeScript La @required caratteristica viene aggiunta, il che significa che verrà applicata in fase di esecuzione dal API gateway che viene distribuito. Per ulteriori informazioni, consulta la documentazione di Smithy.

3. Rinomina il nome del /say-hello.smithy file con uno che sia in linea con le modifiche apportate al codice (ad esempio,). calculate.smithy

4. Passa a e apporta una modifica al codice per avviare l'operazione. packages/apis/mypdkapi/model/src/main/smithy/main.smithy È possibile esporre l'Calculateoperazione definita in /calculate.smithy elencandola nel operations campo di questo file.

   Esempio:

   $version: "2"
   namespace com.aws
   
   use aws.protocols#restJson1
   
   /// A sample smithy api
   @restJson1
   service MyPDKApi {
       version: "1.0"
       operations: [Calculate]
       errors: [
         BadRequestError
         NotAuthorizedError
         InternalFailureError
       ]
   }

5. Crea le modifiche eseguendo il seguente comando:

   npx projen build

   Nota

   Facoltativamente, puoi passare --parallel X flag, che distribuirà la build tra i X core.

   Poiché la @handler caratteristica è stata aggiunta, i seguenti file vengono generati al termine della compilazione:

   • /packages/apis/mypdkapi/handlers/typescript/src/calculate.ts

   • /packages/apis/mypdkapi/handlers/typescript/test/calculate.test.ts

6. Vai al codice packages/apis/mypdkapi/handlers/typescript/src/calculate.ts e apporta modifiche al codice. Questo file è il gestore del server che viene richiamato per. API

   import {
     calculateHandler,
     CalculateChainedHandlerFunction,
     INTERCEPTORS,
     Response,
     LoggingInterceptor,
   } from 'mypdkapi-typescript-runtime';
   
   /**
    * Type-safe handler for the Calculate operation
    */
   export const calculate: CalculateChainedHandlerFunction = async (request) => {
     LoggingInterceptor.getLogger(request).info('Start Calculate Operation');
   
     const { input } = request;
   
     return Response.success({
       result: input.body.numberA + input.body.numberB,
     });
   };
   
   /**
    * Entry point for the AWS Lambda handler for the Calculate operation.
    * The calculateHandler method wraps the type-safe handler and manages marshalling inputs and outputs
    */
   export const handler = calculateHandler(...INTERCEPTORS, calculate);

7. Vai al /packages/apis/mypdkapi/handlers/typescript/test/calculate.test.ts file e apporta modifiche al codice per aggiornare i test unitari.

   Esempio:

   import {
     CalculateChainedRequestInput,
     CalculateResponseContent,
   } from 'mypdkapi-typescript-runtime';
   import {
     calculate,
   } from '../src/calculate';
   
   // Common request arguments
   const requestArguments = {
     chain: undefined as never,
     event: {} as any,
     context: {} as any,
     interceptorContext: {
       logger: {
         info: jest.fn(),
       },
     },
   } satisfies Omit<CalculateChainedRequestInput, 'input'>;
   
   describe('Calculate', () => {
   
     it('should return correct sum', async () => {
       const response = await calculate({
         ...requestArguments,
         input: {
           requestParameters: {},
           body: {
             numberA: 1,
             numberB: 2
           }
         },
       });
   
       expect(response.statusCode).toBe(200);
       expect((response.body as CalculateResponseContent).result).toEqual(3);
     });
   
   });

8. Accedi al /packages/infra/main/src/constructs/apis/mypdkapi.ts file e apporta modifiche al codice per aggiungere un'integrazione per il Calculate funzionamento nella tua CDK infrastruttura. Il API costrutto ha una proprietà di integrazione, in cui puoi inserire l'implementazione che hai aggiunto in precedenza. Poiché state utilizzando la @handler caratteristica del modello Smithy per l'Calculateoperazione, potete utilizzare il CalculateFunction CDK costrutto generato, che è preconfigurato, per indicare l'implementazione del gestore.

   Esempio:

   import { UserIdentity } from "@aws/pdk/identity";
   import { Authorizers, Integrations } from "@aws/pdk/type-safe-api";
   import { Stack } from "aws-cdk-lib";
   import { Cors } from "aws-cdk-lib/aws-apigateway";
   import {
     AccountPrincipal,
     AnyPrincipal,
     Effect,
     PolicyDocument,
     PolicyStatement,
   } from "aws-cdk-lib/aws-iam";
   import { Construct } from "constructs";
   import { Api, CalculateFunction } from "calculateapi-typescript-infra";
   
   /**
    * Api construct props.
    */
   export interface CalculateApiProps {
     /**
      * Instance of the UserIdentity.
      */
     readonly userIdentity: UserIdentity;
   }
   
   /**
    * Infrastructure construct to deploy a Type Safe API.
    */
   export class CalculateApi extends Construct {
     /**
      * API instance
      */
     public readonly api: Api;
   
     constructor(scope: Construct, id: string, props?: CalculateApiProps) {
       super(scope, id);
   
       this.api = new Api(this, id, {
         defaultAuthorizer: Authorizers.iam(),
         corsOptions: {
           allowOrigins: Cors.ALL_ORIGINS,
           allowMethods: Cors.ALL_METHODS,
         },
         integrations: {
           calculate: {
             integration: Integrations.lambda(new CalculateFunction(this, "CalculateFunction"))
           }
         },
         policy: new PolicyDocument({
           statements: [
             // Here we grant any AWS credentials from the account that the prototype is deployed in to call the api.
             // Machine to machine fine-grained access can be defined here using more specific principals (eg roles or
             // users) and resources (ie which api paths may be invoked by which principal) if required.
             // If doing so, the cognito identity pool authenticated role must still be granted access for cognito users to
             // still be granted access to the API.
             new PolicyStatement({
               effect: Effect.ALLOW,
               principals: [new AccountPrincipal(Stack.of(this).account)],
               actions: ["execute-api:Invoke"],
               resources: ["execute-api:/*"],
             }),
             // Open up OPTIONS to allow browsers to make unauthenticated preflight requests
             new PolicyStatement({
               effect: Effect.ALLOW,
               principals: [new AnyPrincipal()],
               actions: ["execute-api:Invoke"],
               resources: ["execute-api:/*/OPTIONS/*"],
             }),
           ],
         }),
       });
   
       // Grant authenticated users access to invoke the api
       props?.userIdentity.identityPool.authenticatedRole.addToPrincipalPolicy(
         new PolicyStatement({
           effect: Effect.ALLOW,
           actions: ["execute-api:Invoke"],
           resources: [this.api.api.arnForExecuteApi("*", "/*", "*")],
         }),
       );
     }
   }

9. Crea le modifiche eseguendo il seguente comando:

   npx projen build

• Conferma e invia le modifiche al tuo feature branch eseguendo i seguenti comandi:

  git add .

  git commit -m "my commit message"

  git push

1. Nel tuo progetto monorepo, esegui una delle seguenti operazioni:

   • Nel pannello di navigazione, scegli Codice, scegli Richieste Pull, quindi scegli Crea richiesta pull.

   • Nella home page del repository, scegli Altro, quindi scegli Crea richiesta pull.

   • Nella pagina del progetto, scegli Crea richiesta pull.

2. Nel repository Source, assicurati che il repository di origine specificato sia quello che contiene il codice commesso. Questa opzione appare solo se non hai creato la pull request dalla pagina principale del repository.

3. Nel ramo di destinazione, scegli il ramo principale in cui unire il codice dopo averlo esaminato.

4. Nel ramo Source, scegli il ramo di funzionalità che contiene il codice commesso.

5. In Pull request title, inserisci un titolo che aiuti gli altri utenti a capire cosa deve essere esaminato e perché.

6. (Facoltativo) Nella descrizione della richiesta Pull, fornisci informazioni come un link ai problemi o una descrizione delle modifiche.

   Suggerimento

   Puoi scegliere Write description for me per generare CodeCatalyst automaticamente una descrizione delle modifiche contenute nella pull request. Puoi apportare modifiche alla descrizione generata automaticamente dopo averla aggiunta alla pull request.

   Questa funzionalità richiede che le funzionalità di intelligenza artificiale generativa siano abilitate per lo spazio. Per ulteriori informazioni, consulta Gestione delle funzionalità di intelligenza artificiale generativa in Amazon CodeCatalyst.

7. In Problemi, scegli Problemi di collegamento, quindi scegli il problema che hai creato inPassaggio 2: crea problemi per collaborare e monitorare il lavoro. Per scollegare un problema, scegli l'icona di scollegamento.

8. (Facoltativo) In Revisori obbligatori, scegli Aggiungi revisori richiesti. Scegli dall'elenco dei membri del progetto per aggiungerli. I revisori obbligatori devono approvare le modifiche prima che la pull request possa essere unita al ramo di destinazione.

   Nota

   Non puoi aggiungere un revisore sia come revisore obbligatorio che come revisore opzionale. Non puoi aggiungerti come revisore.

9. (Facoltativo) In Revisori opzionali, scegli Aggiungi revisori opzionali. Scegli dall'elenco dei membri del progetto per aggiungerli. I revisori opzionali non devono approvare le modifiche come requisito prima che la pull request possa essere unita al ramo di destinazione.

10. La pull request deve essere esaminata e inserita nel ramo principale dai revisori o da te stesso. Per ulteriori informazioni, consulta Unire una pull request.

    Quando le modifiche vengono unite nel ramo principale del repository di origine, viene attivato automaticamente un nuovo flusso di lavoro.

11. Una volta completata l'unione, puoi spostare il problema su Fine.

    1. Nel riquadro di navigazione, scegli Problemi.

    2. Scegli il problema creato inPassaggio 2: crea problemi per collaborare e monitorare il lavoro, scegli il menu a discesa Stato, quindi scegli Fine.

1. Nel pannello di navigazione del tuo progetto monorepo, scegli CI/CD, quindi scegli Flussi di lavoro.

2. Per il flusso di lavoro di rilascio, scegli il flusso di lavoro più recente eseguito per visualizzare i dettagli. Per ulteriori informazioni, consulta Visualizzazione dello stato e dei dettagli di una singola esecuzione.

3. Una volta completata correttamente l'esecuzione del flusso di lavoro, scegli l'ultima azione nel flusso di lavoro (Deploy-B eta-ap-souteast -2), quindi scegli Variabili.

4. Visualizza il sito Web distribuito copiando e incollando il collegamento dal MyPDKApiwebsiteDistributionDomainAssegna un nome alla XXXXX riga in una nuova finestra del browser.

5. Inserisci il nome utente e la password che hai creatoPasso 6: Conferma il flusso di lavoro di rilascio e visualizza il tuo sito web, quindi scegli Accedi.

6. (Facoltativo) Verifica le modifiche nella tua applicazione.

   1. Scegli il menu POSTa discesa.

   2. Inserisci due valori per numberA enumber B, quindi scegli Esegui.

   3. Confermate i risultati nel corpo della risposta.