

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation des types d'action
<a name="action-types"></a>

Les types d'action sont des actions préconfigurées que vous créez en tant que fournisseur pour les clients en utilisant l'un des modèles d'intégration pris en charge dans AWS CodePipeline. 

Vous pouvez demander, consulter et mettre à jour les types d'actions. Si le type d'action est créé pour votre compte en tant que propriétaire, vous pouvez l'utiliser AWS CLI pour afficher ou mettre à jour les propriétés et la structure de votre type d'action. Si vous êtes le fournisseur ou le propriétaire du type d'action, vos clients peuvent choisir l'action et l'ajouter à leurs pipelines une fois qu'elle sera disponible dans CodePipeline.

**Note**  
Vous créez des `custom` actions `owner` sur le terrain à exécuter avec un travailleur. Vous ne les créez pas à l'aide d'un modèle d'intégration. Pour plus d'informations sur les actions personnalisées, consultez[Créez et ajoutez une action personnalisée dans CodePipeline](actions-create-custom-action.md).

**Composants du type d'action**

Les composants suivants constituent un type d'action.
+ **ID du type d'action** : l'*ID* comprend la catégorie, le propriétaire, le fournisseur et la version. L'exemple suivant montre un ID de type d'action avec un propriétaire`ThirdParty`, une catégorie de`Test`, un nom `TestProvider` de fournisseur et une version de`1`.

  ```
              {
                  "Category": "Test",
                  "Owner": "ThirdParty",
                  "Provider": "TestProvider",
                  "Version": "1"
              },
  ```
+ **Configuration de l'exécuteur** : modèle d'intégration, ou moteur d'action, spécifié lors de la création de l'action. Lorsque vous spécifiez l'exécuteur pour un type d'action, vous choisissez l'un des deux types suivants :
  + *Lambda :* le propriétaire du type d'action écrit l'intégration sous la forme d'une fonction Lambda, qui est invoquée CodePipeline chaque fois qu'une tâche est disponible pour l'action.
  + *JobWorker:* Le propriétaire du type d'action écrit l'intégration en tant que job worker qui interroge les offres d'emploi disponibles sur les pipelines clients. Le travailleur exécute ensuite le travail et renvoie le résultat du travail à l'aide CodePipeline de CodePipeline APIs.
**Note**  
Le modèle d'intégration du travailleur au travail n'est pas le modèle d'intégration préféré.
+ **Artefacts d'entrée et de sortie :** limites pour les artefacts que le propriétaire du type d'action désigne pour les clients de l'action.
+ **Autorisations :** stratégie d'autorisation qui désigne les clients autorisés à accéder au type d'action tierce. Les stratégies d'autorisation disponibles dépendent du modèle d'intégration choisi pour le type d'action.
+ **URLs:** liens profonds vers des ressources avec lesquelles le client peut interagir, telles que la page de configuration du propriétaire du type d'action.

**Topics**
+ [Demander un type d'action](#action-types-request)
+ [Ajouter un type d'action disponible à un pipeline (console)](#action-types-in-pipelines)
+ [Afficher un type d'action](#action-types-view-cli)
+ [Mettre à jour un type d'action](#action-types-update-cli)

## Demander un type d'action
<a name="action-types-request"></a>

Lorsqu'un nouveau type CodePipeline d'action est demandé par un fournisseur tiers, le type d'action est créé pour le propriétaire du type d'action dans CodePipeline, et le propriétaire peut gérer et consulter le type d'action.

Un type d'action peut être une action privée ou publique. Lorsque votre type d'action est créé, il est privé. Pour demander qu'un type d'action soit remplacé par une action publique, contactez l'équipe CodePipeline de service.

Avant de créer votre fichier de définition d'action, les ressources de l'exécuteur et la demande de type d'action pour l' CodePipeline équipe, vous devez choisir un modèle d'intégration.



### Étape 1 : Choisissez votre modèle d'intégration
<a name="action-types-choose-model"></a>

Choisissez votre modèle d'intégration, puis créez la configuration pour ce modèle. Après avoir choisi le modèle d'intégration, vous devez configurer vos ressources d'intégration.
+ Pour le modèle d'intégration Lambda, vous créez une fonction Lambda et ajoutez des autorisations. Ajoutez des autorisations à la fonction Lambda de votre intégrateur pour fournir au service CodePipeline les autorisations nécessaires pour l'invoquer à l'aide CodePipeline du principal de service :. `codepipeline.amazonaws.com` Les autorisations peuvent être ajoutées à l'aide CloudFormation de la ligne de commande.
  + Exemple d'ajout d'autorisations à l'aide de CloudFormation :

    ```
      CodePipelineLambdaBasedActionPermission:
        Type: 'AWS::Lambda::Permission'
        Properties:
          Action: 'lambda:invokeFunction'
          FunctionName: {"Fn::Sub": "arn:${AWS::Partition}:lambda:${AWS::Region}:${AWS::AccountId}:function:function-name"}
          Principal: codepipeline.amazonaws.com
    ```
  + [Documentation pour la ligne de commande](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html)
+ Pour le modèle d'intégration du travailleur, vous créez une intégration avec une liste de comptes autorisés sur laquelle le travailleur interroge des offres d'emploi auprès du CodePipeline APIs.

### Étape 2 : Création d'un fichier de définition du type d'action
<a name="action-type-definition-file"></a>

Vous définissez un type d'action dans un fichier de définition de type d'action à l'aide de JSON. Dans le fichier, vous incluez la catégorie d'action, le modèle d'intégration utilisé pour gérer le type d'action et les propriétés de configuration. 

**Note**  
Une fois que vous avez créé une action publique, vous ne pouvez pas modifier la propriété du type d'action située `properties` entre `optional` et`required`. Vous ne pouvez pas non plus modifier le`owner`.

Pour plus d'informations sur les paramètres du fichier de définition du type d'action, consultez [ActionTypeDeclaration](https://docs.aws.amazon.com/cli/latest/reference/codepipelineAPI_ActionTypeDeclaration.html)et [UpdateActionType](https://docs.aws.amazon.com/cli/latest/reference/codepipelineAPI_UpdateActionType.html)dans le Guide de [référence de l'CodePipeline API](https://docs.aws.amazon.com/cli/latest/reference/codepipeline). 

Le fichier de définition du type d'action comporte huit sections :
+ `description`: description du type d'action à mettre à jour.
+ `executor`: informations sur l'exécuteur pour un type d'action créé avec un modèle d'intégration pris en charge, `Lambda` soit`job worker`. Vous ne pouvez fournir que l'un `jobWorkerExecutorConfiguration` ou l'autre ou`lambdaExecutorConfiguration`, en fonction de votre type d'exécuteur testamentaire.
  + `configuration`: ressources pour la configuration du type d'action, en fonction du modèle d'intégration choisi. Pour le modèle d'intégration Lambda, utilisez la fonction Lambda ARN. Pour le modèle d'intégration du travailleur, utilisez le compte ou la liste des comptes à partir desquels le travailleur travaille.
  + `jobTimeout`: délai d'expiration de la tâche en secondes. L'exécution d'une action peut consister en plusieurs tâches. Il s'agit du délai d'attente pour une seule tâche, et non pour l'exécution complète de l'action.
**Note**  
Pour le modèle d'intégration Lambda, le délai d'expiration maximal est de 15 minutes.
  + `policyStatementsTemplate`: déclaration de politique qui spécifie les autorisations nécessaires dans le compte du CodePipeline client pour exécuter correctement une action.
  + `type`: le modèle d'intégration utilisé pour créer et mettre à jour le type d'action, `Lambda` soit`JobWorker`.
+ `id`: la catégorie, le propriétaire, le fournisseur et l'ID de version pour le type d'action : 
  + `category`: Le type d'action peut être effectué à l'étape suivante : source, génération, déploiement, test, appel ou approbation. 
  + `provider`: fournisseur du type d'action appelé, tel que la société du fournisseur ou le nom du produit. Le nom du fournisseur est fourni lors de la création du type d'action.
  + `owner`: le créateur du type d'action appelé : `AWS` ou`ThirdParty`.
  + `version`: chaîne utilisée pour versionner le type d'action. Pour la première version, définissez le numéro de version sur 1.
+ `inputArtifactDetails`: le nombre d'artefacts attendus de l'étape précédente du pipeline.
+ `outputArtifactDetails`: le nombre d'artefacts que l'on peut attendre du résultat de l'étape du type d'action. 
+ `permissions`: détails identifiant les comptes autorisés à utiliser le type d'action.
+ `properties`: les paramètres nécessaires à l'exécution des tâches de votre projet.
  + `description`: description de la propriété qui est affichée aux utilisateurs.
  + `optional`: si la propriété de configuration est facultative.
  + `noEcho`: si la valeur du champ saisie par le client est omise du journal. Si`true`, alors la valeur est expurgée lorsqu'elle est renvoyée avec une demande d' GetPipeline API.
  + `key`: si la propriété de configuration est une clé.
  + `queryable`: si la propriété est utilisée pour le sondage. Un type d'action peut avoir jusqu'à une propriété interrogeable. Si c'est le cas, cette propriété doit être à la fois obligatoire et non secrète.
  + `name`: nom de propriété affiché aux utilisateurs.
+ `urls`: liste des URLs CodePipeline écrans destinés à vos utilisateurs.
  + `entityUrlTemplate`: URL vers les ressources externes pour le type d'action, telles qu'une page de configuration.
  + `executionUrlTemplate`: URL vers les détails de la dernière exécution de l'action.
  + `revisionUrlTemplate`: URL affichée dans la CodePipeline console vers la page où les clients peuvent mettre à jour ou modifier la configuration de l'action externe.
  + `thirdPartyConfigurationUrl`: URL d'une page où les utilisateurs peuvent s'inscrire à un service externe et effectuer la configuration initiale de l'action fournie par ce service.

Le code suivant montre un exemple de fichier de définition de type d'action.

```
{
   "actionType": { 
      "description": "string",
      "executor": { 
         "configuration": { 
            "jobWorkerExecutorConfiguration": { 
               "pollingAccounts": [ "string" ],
               "pollingServicePrincipals": [ "string" ]
            },
            "lambdaExecutorConfiguration": { 
               "lambdaFunctionArn": "string"
            }
         },
         "jobTimeout": number,
         "policyStatementsTemplate": "string",
         "type": "string"
      },
      "id": { 
         "category": "string",
         "owner": "string",
         "provider": "string",
         "version": "string"
      },
      "inputArtifactDetails": { 
         "maximumCount": number,
         "minimumCount": number
      },
      "outputArtifactDetails": { 
         "maximumCount": number,
         "minimumCount": number
      },
      "permissions": { 
         "allowedAccounts": [ "string" ]
      },
      "properties": [ 
         { 
            "description": "string",
            "key": boolean,
            "name": "string",
            "noEcho": boolean,
            "optional": boolean,
            "queryable": boolean
         }
      ],
      "urls": { 
         "configurationUrl": "string",
         "entityUrlTemplate": "string",
         "executionUrlTemplate": "string",
         "revisionUrlTemplate": "string"
      }
   }
}
```



### Étape 3 : Enregistrez votre intégration auprès de CodePipeline
<a name="action-types-register"></a>

Pour enregistrer votre type d'action auprès de l'équipe de service CodePipeline, vous devez contacter l'équipe du CodePipeline service avec votre demande.

L'équipe CodePipeline de service enregistre l'intégration du nouveau type d'action en apportant des modifications à la base de code du service. CodePipeline enregistre deux nouvelles actions : une *action publique* et une *action privée*. Vous utilisez l'action privée pour les tests, puis lorsque vous êtes prêt, vous activez l'action publique pour servir le trafic client.

**Pour enregistrer une demande d'intégration Lambda**
+ Envoyez une demande à l'équipe CodePipeline de service en utilisant le formulaire suivant.

  ```
  This issue will track the onboarding of [Name] in CodePipeline.
  
  
  [Contact engineer] will be the primary point of contact for this integration.
  
  Name of the action type as you want it to appear to customers: Example.com Testing
  
  Initial onboard checklist:
  
  1. Attach an action type definition file in JSON format. This includes the schema for the action type
  
  2. A list of test accounts for the allowlist which can access the new action type [{account, account_name}]
  
  3. The Lambda function ARN
  
  4. List of Régions AWS where your action will be available
  
  5. Will this be available as a public action?
  ```

**Pour enregistrer une demande d'intégration d'un travailleur**
+ Envoyez une demande à l'équipe CodePipeline de service en utilisant le formulaire suivant.

  ```
  This issue will track the onboarding of [Name] in CodePipeline.
  
  [Contact engineer] will be the primary point of contact for this integration.
  
  
  Name of the action type as you want it to appear to customers: Example.com Testing
  
  Initial onboard checklist:
  
  1. Attach an action type definition file in JSON format. This includes the schema for the action type.
  
  2. A list of test accounts for the allowlist which can access the new action type [{account, account_name}]
  
  3. URL information:
  Website URL: https://www.example.com/%TestThirdPartyName%/%TestVersionNumber%
  
  Example URL pattern where customers will be able to review their configuration information for the action: https://www.example.com/%TestThirdPartyName%/%customer-ID%/%CustomerActionConfiguration%
  
  Example runtime URL pattern: https://www.example.com/%TestThirdPartyName%/%customer-ID%/%TestRunId%
  
  4. List of Régions AWS where your action will be available
  
  5. Will this be available as a public action?
  ```

### Étape 4 : Activez votre nouvelle intégration
<a name="action-types-activate"></a>

Contactez l'équipe CodePipeline de service lorsque vous serez prêt à utiliser la nouvelle intégration publiquement.

## Ajouter un type d'action disponible à un pipeline (console)
<a name="action-types-in-pipelines"></a>

Vous ajoutez votre type d'action à un pipeline afin de pouvoir le tester. Vous pouvez le faire en créant un nouveau pipeline ou en modifiant un pipeline existant. 

**Note**  
Si votre type d'action est une action de catégorie source, build ou deploy, vous pouvez l'ajouter en créant un pipeline. Si votre type d'action appartient à la catégorie test, vous devez l'ajouter en modifiant un pipeline existant.

**Pour ajouter votre type d'action à un pipeline existant depuis la CodePipeline console**

1. Connectez-vous à la CodePipeline console AWS Management Console et ouvrez-la à l'[adresse http://console.aws.amazon. com/codesuite/codepipeline/home](https://console.aws.amazon.com/codesuite/codepipeline/home).

1. Dans la liste des pipelines, choisissez le pipeline dans lequel vous souhaitez ajouter le type d'action.

1. Sur la page d'affichage récapitulatif du pipeline, choisissez **Modifier**.

1. Choisissez de modifier l'étape. À l'étape où vous souhaitez ajouter votre type d'action, choisissez **Ajouter un groupe d'actions**. La page **Modifier l'action** s'affiche.

1. Sur la page **Modifier l'action**, dans **Nom de l'action**, entrez le nom de l'action. Il s'agit du nom qui s'affiche pour l'étape de votre pipeline.

1. Dans **Fournisseur d'actions**, choisissez votre type d'action dans la liste. 

   Notez que la valeur de la liste est basée sur celle `provider` spécifiée dans le fichier de définition du type d'action.

1. Dans **Artefacts d'entrée**, entrez le nom de l'artefact au format suivant :

   `Artifactname::FileName`

   Notez que les quantités minimales et maximales autorisées sont définies en fonction de celles `inputArtifactDetails` spécifiées dans le fichier de définition du type d'action.

1. Choisissez **Connect to**<Action\$1Name>.

   Une fenêtre de navigateur s'ouvre et se connecte au site Web que vous avez créé pour votre type d'action.

1. Connectez-vous à votre site Web en tant que client et suivez les étapes suivies par un client pour utiliser votre type d'action. Vos étapes varient en fonction de votre catégorie d'action, de votre site Web et de votre configuration, mais elles incluent généralement une action d'achèvement qui renvoie le client à la page **Modifier l'action**.

1. Dans la page CodePipeline **Modifier l'action**, les champs de configuration supplémentaires pour l'action s'affichent. Les champs qui s'affichent correspondent aux propriétés de configuration que vous avez spécifiées dans le fichier de définition d'action. Entrez les informations dans les champs personnalisés pour votre type d'action.

   Par exemple, si le fichier de définition d'action spécifie une propriété nommée`Host`, un champ portant le libellé **Hôte** s'affiche sur la page **Modifier l'action** correspondant à votre action.

1. Dans **Artefacts de sortie**, entrez le nom de l'artefact au format suivant :

   `Artifactname::FileName`

   Notez que les quantités minimales et maximales autorisées sont définies en fonction de celles `outputArtifactDetails` spécifiées dans le fichier de définition du type d'action.

1. Choisissez **Terminé** pour revenir à la page des détails du pipeline.
**Note**  
Vos clients peuvent éventuellement utiliser la CLI pour ajouter le type d'action à leur pipeline. 

1. Pour tester votre action, validez une modification de la source spécifiée dans l'étape source du pipeline ou suivez les étapes décrites dans [Démarrer manuellement un pipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/how-to-manually-start.html).

Pour créer un pipeline avec votre type d'action, suivez les étapes décrites [Création d'un pipeline, d'étapes et d'actions](pipelines-create.md) et choisissez votre type d'action parmi autant d'étapes que vous allez tester.

## Afficher un type d'action
<a name="action-types-view-cli"></a>

Vous pouvez utiliser la CLI pour afficher votre type d'action. Utilisez la **get-action-type** commande pour afficher les types d'action créés à l'aide d'un modèle d'intégration.

**Pour afficher un type d'action**

1. Créez un fichier JSON d'entrée et nommez-le`file.json`. Ajoutez votre identifiant de type d'action au format JSON, comme indiqué dans l'exemple suivant.

   ```
   {
       "category": "Test",
       "owner": "ThirdParty",
       "provider": "TestProvider",
       "version": "1"
   }
   ```

1. Dans une fenêtre de terminal ou sur la ligne de commande, exécutez la **get-action-type** commande.

   ```
   aws codepipeline get-action-type --cli-input-json file://file.json
   ```

   Cette commande renvoie la sortie de définition d'action pour un type d'action. Cet exemple montre un type d'action créé avec le modèle d'intégration Lambda.

   ```
   {
       "actionType": {
           "executor": {
               "configuration": {
                   "lambdaExecutorConfiguration": {
                       "lambdaFunctionArn": "arn:aws:lambda:us-west-2:<account-id>:function:my-function"
                   }
               },
               "type": "Lambda"
           },
           "id": {
               "category": "Test",
               "owner": "ThirdParty",
               "provider": "TestProvider",
               "version": "1"
           },
           "inputArtifactDetails": {
               "minimumCount": 0,
               "maximumCount": 1
           },
           "outputArtifactDetails": {
               "minimumCount": 0,
               "maximumCount": 1
           },
           "permissions": {
               "allowedAccounts": [
                   "<account-id>"
               ]
           },
           "properties": []
       }
   }
   ```

## Mettre à jour un type d'action
<a name="action-types-update-cli"></a>

Vous pouvez utiliser la CLI pour modifier les types d'actions créés avec un modèle d'intégration.

Pour un type d'action publique, vous ne pouvez pas mettre à jour le propriétaire, vous ne pouvez pas remplacer les propriétés facultatives par des propriétés obligatoires et vous pouvez uniquement ajouter de nouvelles propriétés facultatives.

1. Utilisez la `get-action-type` commande pour obtenir la structure de votre type d'action. Copiez la structure.

1. Créez un fichier JSON d'entrée et nommez-le`action.json`. Collez-y la structure du type d'action que vous avez copiée à l'étape précédente. Mettez à jour les paramètres que vous souhaitez modifier. Vous pouvez également ajouter des paramètres facultatifs. 

   Pour plus d'informations sur les paramètres du fichier d'entrée, consultez la description du fichier de définition d'action dans[Étape 2 : Création d'un fichier de définition du type d'action](#action-type-definition-file).

   L'exemple suivant montre comment mettre à jour un exemple de type d'action créé avec le modèle d'intégration Lambda. Cet exemple apporte les modifications suivantes :
   + Change le `provider` nom en`TestProvider1`.
   + Ajoutez une limite de délai d'expiration des tâches de 900 secondes.
   + Ajoute une propriété de configuration d'action nommée `Host` qui est affichée au client à l'aide de l'action.

     ```
     {
         "actionType": {
             "executor": {
                 "configuration": {
                     "lambdaExecutorConfiguration": {
                         "lambdaFunctionArn": "arn:aws:lambda:us-west-2:<account-id>:function:my-function"
                     }
                 },
                 "type": "Lambda",
                 "jobTimeout": 900 
             },
             "id": {
                 "category": "Test",
                 "owner": "ThirdParty",
                 "provider": "TestProvider1",
                 "version": "1"
             },
             "inputArtifactDetails": {
                 "minimumCount": 0,
                 "maximumCount": 1
             },
             "outputArtifactDetails": {
                 "minimumCount": 0,
                 "maximumCount": 1
             },
             "permissions": {
                 "allowedAccounts": [
                     "account-id"
                 ]
             },
             "properties": {
              "description": "Owned build action parameter description",
              "optional": true,
              "noEcho": false,
              "key": true,
              "queryable": false,
              "name": "Host"
              }
         }
     }
     ```

1. Sur le terminal ou sur la ligne de commande, exécutez la **update-action-type** commande

   ```
   aws codepipeline update-action-type --cli-input-json file://action.json
   ```

   Cette commande renvoie la sortie du type d'action correspondant à vos paramètres mis à jour.