

Ceci est le guide du développeur du AWS CDK v2. L'ancien CDK v1 est entré en maintenance le 1er juin 2022 et a pris fin le 1er juin 2023.

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.

# Travailler avec le AWS CDK dans Go
<a name="work-with-cdk-go"></a>

 Goest un langage client entièrement pris en charge par le AWS Cloud Development Kit (AWS CDK) et est considéré comme stable. L'utilisation du AWS CDK dans Go utilise des outils familiers. La version Go du AWS CDK utilise même des identifiants de type Go.

Contrairement aux autres langages pris en charge par le CDK, Go il ne s'agit pas d'un langage de programmation orienté objet traditionnel. Goutilise la composition alors que d'autres langages exploitent souvent l'héritage. Nous avons essayé d'utiliser des Go approches idiomatiques autant que possible, mais il y a des endroits où le CDK peut différer.

Cette rubrique fournit des conseils lors de l'utilisation du AWS CDK dansGo. Consultez le billet de [blog consacré à l'annonce](https://aws.amazon.com/blogs/developer/getting-started-with-the-aws-cloud-development-kit-and-go/) pour une présentation d'un projet Go simple pour le AWS CDK.

## Premiers pas avec Go
<a name="go-prerequisites"></a>

Pour utiliser le AWS CDK, vous devez disposer d'un AWS compte et d'informations d'identification et avoir installé Node.js et le kit d'outils AWS CDK. Consultez [Commencer à utiliser le AWS CDK.](getting-started.md)

Les Go liaisons pour le AWS CDK utilisent la [chaîne d'outils Go](https://golang.org/dl/) standard, v1.23 ou ultérieure. Vous pouvez utiliser l'éditeur de votre choix.

**Note**  
Obsolète linguistique tierce : la version linguistique n'est prise en charge que jusqu'à sa fin de vie (EOL) partagée par le fournisseur ou la communauté et est sujette à modification avec préavis.

## Création d’un projet
<a name="go-newproject"></a>

Vous créez un nouveau projet AWS CDK en l'appelant `cdk init` dans un répertoire vide. Utilisez l'`--language`option et spécifiez `go` :

```
mkdir my-project
cd my-project
cdk init app --language go
```

 `cdk init`utilise le nom du dossier du projet pour nommer les différents éléments du projet, notamment les classes, les sous-dossiers et les fichiers. Les traits d'union figurant dans le nom du dossier sont convertis en traits de soulignement. Toutefois, le nom doit sinon prendre la forme d'un Go identifiant ; par exemple, il ne doit pas commencer par un chiffre ni contenir d'espaces.

Le projet qui en résulte inclut une référence au Go module AWS CDK de base`github.com/aws/aws-cdk-go/awscdk/v2`, dans`go.mod`. Problème lors `go get` de l'installation de ce module et des autres modules requis.

## Gestion des modules AWS de la bibliothèque Construct
<a name="go-managemodules"></a>

Dans la plupart des documentations et exemples du AWS CDK, le mot « module » est souvent utilisé pour désigner les modules de la bibliothèque de AWS construction, un ou plusieurs par AWS service, ce qui diffère de l'Goutilisation idiomatique du terme. La bibliothèque CDK Construct est fournie dans un Go module avec les modules individuels de la bibliothèque de construction, qui prennent en charge les différents AWS services, fournis sous forme de Go packages dans ce module.

La prise en charge de la bibliothèque de AWS construction de certains services se trouve dans plusieurs modules de bibliothèque de construction (Gopackage). Par exemple, Amazon Route 53 possède trois modules Construct Library en plus `awsroute53` du package principal`awsroute53patterns`, nommé`awsroute53resolver`, et`awsroute53targets`.

Le package de base du AWS CDK, dont vous aurez besoin dans la plupart des applications AWS CDK, est importé sous forme de Go code au format. `github.com/aws/aws-cdk-go/awscdk/v2` Des packages pour les différents services de la bibliothèque AWS Construct se trouvent sous cette rubrique`github.com/aws/aws-cdk-go/awscdk/v2`. Par exemple, l'espace de noms du module Amazon S3 est`github.com/aws/aws-cdk-go/awscdk/v2/awss3`.

```
import (
        "github.com/aws/aws-cdk-go/awscdk/v2/awss3"
        // ...
)
```

Une fois que vous avez importé les modules de la bibliothèque Construct (Gopackages) pour les services que vous souhaitez utiliser dans votre application, vous accédez aux constructions de ce module en utilisant, par exemple,`awss3.Bucket`.

## Gestion des dépendances dans Go
<a name="work-with-cdk-go-dependencies"></a>

DansGo, les versions des dépendances sont définies dans`go.mod`. La valeur par défaut `go.mod` est similaire à celle présentée ici.

```
module my-package

go 1.16

require (
  github.com/aws/aws-cdk-go/awscdk/v2 v2.16.0
  github.com/aws/constructs-go/constructs/v10 v10.0.5
  github.com/aws/jsii-runtime-go v1.29.0
)
```

Les noms des packages (modules, dans le langage Go) sont spécifiés par URL avec le numéro de version requis ajouté. Gole système de modules ne prend pas en charge les plages de versions.

Émettez la `go get` commande pour installer tous les modules requis et les mettre à jour`go.mod`. Pour voir la liste des mises à jour disponibles pour vos dépendances, publiez`go list -m -u all`.

## AWS Expressions idiomatiques CDK dans Go
<a name="go-cdk-idioms"></a>

### Noms des champs et des méthodes
<a name="go-naming"></a>

Les noms de champs et de méthodes utilisent camel casing (`likeThis`) dans TypeScript, la langue d'origine du CDK. DansGo, ils suivent les Go conventions, tout comme Pascal-cased (). `LikeThis`

### Nettoyage
<a name="go-cdk-jsii-close"></a>

Dans votre `main` méthode, utilisez-le `defer jsii.Close()` pour vous assurer que votre application CDK se nettoie d'elle-même.

### Valeurs manquantes et conversion du pointeur
<a name="go-missing-values"></a>

DansGo, les valeurs manquantes dans les objets AWS CDK tels que les ensembles de propriétés sont représentées par. `nil` Gon'a pas de types nullables ; le seul type qui peut contenir `nil` est un pointeur. Pour permettre aux valeurs d'être facultatives, toutes les propriétés, tous les arguments et toutes les valeurs de retour du CDK sont des pointeurs, même pour les types primitifs. Cela s'applique aux valeurs obligatoires ainsi qu'aux valeurs facultatives. Ainsi, si une valeur requise devient facultative ultérieurement, aucun changement radical de type n'est nécessaire.

Lorsque vous transmettez des valeurs ou des expressions littérales, utilisez les fonctions d'assistance suivantes pour créer des pointeurs vers les valeurs.
+  `jsii.String` 
+  `jsii.Number` 
+  `jsii.Bool` 
+  `jsii.Time` 

Pour des raisons de cohérence, nous vous recommandons d'utiliser des pointeurs de la même manière lorsque vous définissez vos propres constructions, même s'il peut sembler plus pratique, par exemple, de recevoir vos constructions `id` sous forme de chaîne plutôt que de pointeur vers une chaîne.

Lorsque vous utilisez des valeurs AWS CDK facultatives, y compris des valeurs primitives ainsi que des types complexes, vous devez tester explicitement les pointeurs pour vous assurer qu'ils ne le sont pas `nil` avant de faire quoi que ce soit avec eux. Go n'a pas de « sucre syntaxique » pour aider à gérer les valeurs vides ou manquantes comme le font d'autres langages. Cependant, l'existence des valeurs requises dans les ensembles de propriétés et les structures similaires est garantie (sinon la construction échoue), il n'est donc pas nécessaire de vérifier ces valeurs. `nil`

### Constructions et accessoires
<a name="go-props"></a>

Les constructions, qui représentent une ou plusieurs AWS ressources et leurs attributs associés, sont représentées Go sous forme d'interfaces. Par exemple, `awss3.Bucket` c'est une interface. Chaque construction possède une fonction d'usine, telle que `awss3.NewBucket` celle de renvoyer une structure qui implémente l'interface correspondante.

Toutes les fonctions d'usine prennent trois arguments : le paramètre `scope` dans lequel la construction est définie (son parent dans l'arbre de construction)`id`, un`props`, et un ensemble de key/value paires que la construction utilise pour configurer les ressources qu'elle crée. Le modèle « bundle of attributes » est également utilisé ailleurs dans le AWS CDK.

DansGo, les accessoires sont représentés par un type de structure spécifique pour chaque construction. Par exemple, an `awss3.Bucket` prend un argument props de type`awss3.BucketProps`. Utilisez une structure littérale pour écrire les arguments des accessoires.

```
var bucket = awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
    Versioned: jsii.Bool(true),
})
```

### Structures génériques
<a name="go-generic-structures"></a>

À certains endroits, le AWS CDK utilise des JavaScript tableaux ou des objets non typés comme entrée d'une méthode. (Voir, par exemple, AWS CodeBuild la [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue)méthode.) Dans Go, ces objets sont respectivement représentés sous forme de tranches et d'interface vide.

Le CDK fournit des fonctions d'assistance variadiques, par exemple `jsii.Strings` pour créer des tranches contenant des types primitifs.

```
jsii.Strings("One", "Two", "Three")
```

### Fonctionne avec n'importe quelle tranche
<a name="go-any-slice"></a>

Certaines constructions attendent des propriétés qui sont une liste de plusieurs types (types d'union inclus TypeScript). DansGo, ils sont sous la forme d'une tranche de any (`*[]any`). `any`Cela garantit que le compilateur autorisera l'attribution de différents types à cet endroit. Reportez-vous à la documentation du ` [AWS CDK Go package](https://pkg.go.dev/github.com/aws/aws-cdk-go/awscdk/v2) ` pour savoir quels sont les types autorisés.

Pour utiliser de telles propriétés, utilisez les fonctions d'assistance fournies par `jsii` pour créer des tranches de différents types :
+  `jsii.AnySlice` 
+  `jsii.AnyStrings` 
+  `jsii.AnyNumbers` 

Par exemple :

```
func Arns() *[]*string {
a := "arn:aws:s3:::bucket1"
b := "arn:aws:s3:::bucket2"
return &[]*string{&a, &b}
}

awsiam.NewCfnUser(stack, jsii.String("User"), &awsiam.CfnUserProps{
	ManagedPolicyArns: jsii.AnySlice(Arns())
  // or
	ManagedPolicyArns: jsii.AnyStrings("arn:aws:s3:::bucket1", "arn:aws:s3:::bucket2")
  // or
  ManagedPolicyArns: &[]interface{}{
    jsii.String("arn:aws:s3:::bucket1"),
    jsii.String("arn:aws:s3:::bucket2"),
  }
})
```

Cette approche garantit que vos tranches sont correctement interprétées par le CDK, évitant ainsi les erreurs de désérialisation lors du déploiement ou de la synthèse de vos piles.

### Développement de constructions personnalisées
<a name="go-writing-constructs"></a>

DansGo, il est généralement plus simple d'écrire une nouvelle construction que d'étendre une construction existante. Définissez d'abord un nouveau type de structure, en incorporant de manière anonyme un ou plusieurs types existants si vous souhaitez une sémantique semblable à une extension. Écrivez des méthodes pour chaque nouvelle fonctionnalité que vous ajoutez et les champs nécessaires pour contenir les données dont ils ont besoin. Définissez une interface d'accessoires si votre construction en a besoin. Enfin, écrivez une fonction d'usine `NewMyConstruct()` pour renvoyer une instance de votre construction.

Si vous modifiez simplement certaines valeurs par défaut d'une construction existante ou si vous ajoutez un comportement simple lors de l'instanciation, vous n'avez pas besoin de toute cette plomberie. Écrivez plutôt une fonction d'usine qui appelle la fonction d'usine de la construction que vous « étendez ». Dans d'autres langages CDK, par exemple, vous pouvez créer une `TypedBucket` construction qui impose le type d'objets dans un compartiment Amazon S3 en remplaçant le `s3.Bucket` type et, dans l'initialiseur de votre nouveau type, en ajoutant une politique de compartiment autorisant uniquement l'ajout d'extensions de nom de fichier spécifiées au compartiment. DansGo, il est plus facile de simplement écrire un `NewTypedBucket` qui renvoie un `s3.Bucket` (instancié à l'aide`s3.NewBucket`) auquel vous avez ajouté une politique de compartiment appropriée. Aucun nouveau type de construction n'est nécessaire car la fonctionnalité est déjà disponible dans la construction standard du bucket ; la nouvelle « construction » fournit simplement un moyen plus simple de la configurer.

## Création, synthèse et déploiement
<a name="go-running"></a>

Le AWS CDK compile automatiquement votre application avant de l'exécuter. Cependant, il peut être utile de créer votre application manuellement pour vérifier les erreurs et exécuter des tests. Vous pouvez le faire `go build` en lançant une commande dans le répertoire racine de votre projet.

Exécutez tous les tests que vous avez écrits `go test` à l'aide d'une invite de commande.

## Résolution des problèmes
<a name="go-troubleshooting"></a>

Si vous rencontrez une erreur de compilation comme celle-ci, cela signifie que des tranches de chaîne ont été transmises directement à une propriété qui attend une tranche quelconque.

```
Cannot use 'jsii.Strings("arn:aws:s3:::bucket1", "arn:aws:s3:::bucket2")' (type *[]*string) as the type *[]interface{}
```

Pour résoudre cette erreur, remplacez `jsii.Strings()` par`jsii.AnyStrings()`. Consultez ceci ` [CDK GitHub issue](https://github.com/aws/aws-cdk/issues/35630) ` pour plus de contexte et des solutions supplémentaires.