

Esta es la guía para desarrolladores de AWS CDK v2. La primera versión del CDK pasó a la etapa de mantenimiento el 1.° de junio de 2022 y no cuenta con soporte desde el 1.° de junio de 2023.

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Trabajando con el AWS CDK en Go
<a name="work-with-cdk-go"></a>

 Goes un lenguaje de cliente totalmente compatible con el AWS Cloud Development Kit (AWS CDK) y se considera estable. Para trabajar con el AWS CDK en Go se utilizan herramientas conocidas. La versión Go del AWS CDK incluso usa identificadores tipo Go.

A diferencia de los otros lenguajes compatibles con CDK, Go no es un lenguaje de programación tradicional orientado a objetos. Go utiliza la composición, mientras que otros lenguajes suelen aprovechar la herencia. Hemos intentado emplear enfoques idiomáticos de Go en la medida de lo posible, sin embargo, existen aspectos en los que el CDK puede diferir.

En este tema se proporcionan instrucciones para trabajar con la AWS CDK en. Go Consulta la entrada del [blog sobre el anuncio](https://aws.amazon.com/blogs/developer/getting-started-with-the-aws-cloud-development-kit-and-go/) para ver un tutorial de un sencillo proyecto de Go para el AWS CDK.

## Introducción a Go
<a name="go-prerequisites"></a>

Para trabajar con el AWS CDK, debe tener una AWS cuenta y credenciales, y tener instalados Node.js y el kit de herramientas del AWS CDK. Consulte [Primeros pasos con](getting-started.md) el CDK. AWS 

Los Go enlaces del AWS CDK utilizan la [cadena de herramientas Go](https://golang.org/dl/) estándar, versión 1.23 o posterior. Puede utilizar el editor de su elección.

**nota**  
Obsolescencia del lenguaje de terceros: la versión en otro lenguaje solo se admite hasta que el proveedor o la comunidad compartan su fecha de vida útil (EOL), y está sujeta a cambios con previo aviso.

## Creación de un proyecto
<a name="go-newproject"></a>

Para crear un nuevo proyecto de AWS CDK, se invoca en un directorio vacío. `cdk init` Utilice la opción `--language` y especifique `go`:

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

 `cdk init` utiliza el nombre de la carpeta del proyecto para asignar un nombre a varios elementos del proyecto, incluidas las clases, las subcarpetas y los archivos. Los guiones del nombre de la carpeta se convierten en guiones bajos. Sin embargo, de lo contrario, el nombre debe seguir la forma de un identificador de Go; por ejemplo, no debe comenzar por un número ni contener espacios.

El proyecto resultante incluye una referencia al Go módulo AWS CDK principal, `github.com/aws/aws-cdk-go/awscdk/v2` en. `go.mod` Ejecute `go get` para instalar este y otros módulos necesarios.

## Gestión de los módulos de AWS Construct Library
<a name="go-managemodules"></a>

En la mayoría de la documentación y los ejemplos de AWS CDK, la palabra «módulo» suele usarse para referirse a los módulos de AWS Construct Library, uno o más por AWS servicio, lo que difiere del Go uso idiomático del término. La biblioteca Construct de CDK se proporciona en un Go módulo con los módulos individuales de la biblioteca Construct, que admiten los distintos AWS servicios y que se proporcionan como Go paquetes dentro de ese módulo.

La compatibilidad con AWS Construct Library de algunos servicios se encuentra en más de un módulo (Gopaquete) de Construct Library. Por ejemplo, Amazon Route 53 tiene tres módulos de la Biblioteca de constructos, además del paquete principal de `awsroute53`, denominados `awsroute53patterns` `awsroute53resolver` y `awsroute53targets`.

El paquete principal del AWS CDK, que necesitarás en la mayoría de las aplicaciones de AWS CDK, se importa en Go código como. `github.com/aws/aws-cdk-go/awscdk/v2` Los paquetes de los distintos servicios de la biblioteca AWS Construct se encuentran en. `github.com/aws/aws-cdk-go/awscdk/v2` Por ejemplo, el espacio de nombres del módulo Amazon S3 es `github.com/aws/aws-cdk-go/awscdk/v2/awss3`.

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

Una vez que haya importado los módulos de la Biblioteca de constructos (paquetes Go) para los servicios que desee usar en su aplicación, podrá acceder a las construcciones de ese módulo utilizando, por ejemplo, `awss3.Bucket`.

## Administración de dependencias en Go
<a name="work-with-cdk-go-dependencies"></a>

En Go, las versiones de las dependencias se definen en `go.mod`. El valor predeterminado `go.mod` es similar al que se muestra aquí.

```
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
)
```

Los nombres de los paquetes (módulos, en el lenguaje de Go) se especifican a través de una URL con el número de versión requerido adjunto. El sistema del módulo de Go no admite los rangos de versiones.

Ejecute el comando `go get` para instalar todos los módulos necesarios y actualizarlos en `go.mod`. Para ver una lista de las actualizaciones disponibles para sus dependencias, ejecute `go list -m -u all`.

## AWS Los modismos de CDK están en Go
<a name="go-cdk-idioms"></a>

### Nombres de campos y métodos
<a name="go-naming"></a>

Los nombres de campos y métodos utilizan camel casey (`likeThis`) en TypeScript, el idioma de origen del CDK. En Go, estos siguen las convenciones de Go, al igual que las mayúsculas (`LikeThis`).

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

En su método `main`, use `defer jsii.Close()` para asegurarse de que la aplicación CDK se limpie sola.

### Valores faltantes y conversión de punteros
<a name="go-missing-values"></a>

EnGo, los valores que faltan en los objetos AWS CDK, como los paquetes de propiedades, se representan con. `nil` Gono tiene tipos anulables; el único tipo que puede contener `nil` es un puntero. Por lo tanto, para permitir que los valores sean opcionales, todas las propiedades, argumentos y valores de retorno de CDK son punteros, incluso en el caso de los tipos primitivos. Esto se aplica tanto a los valores obligatorios como opcionales. Si un valor obligatorio se vuelve opcional, no será necesario cambiar el tipo de valor.

Al pasar valores o expresiones literales, utilice las siguientes funciones auxiliares para crear punteros a los valores.
+  `jsii.String` 
+  `jsii.Number` 
+  `jsii.Bool` 
+  `jsii.Time` 

Para mantener la coherencia, recomendamos que utilice los punteros de forma similar cuando defina sus propios constructos, aunque pueda parecer más conveniente, por ejemplo, recibir constructos como una cadena en lugar de `id` como puntero a una cadena.

Cuando se trate de valores AWS CDK opcionales, incluidos valores primitivos y tipos complejos, deberías probar los punteros de forma explícita para asegurarte de que no lo están `nil` antes de hacer cualquier cosa con ellos. Go no tiene “azúcar sintáctico” que ayude a gestionar los valores vacíos o faltantes, como ocurre en otros lenguajes. Sin embargo, se garantiza la existencia de los valores obligatorios en las agrupaciones de propiedades y estructuras similares (de lo contrario, los constructos no funcionan), por lo que no es necesario verificar `nil` en estos valores.

### Constructos y accesorios
<a name="go-props"></a>

Las construcciones, que representan uno o más AWS recursos y sus atributos asociados, se representan como interfaces. Go Por ejemplo, `awss3.Bucket` es una interfaz. Cada constructo tiene una función de fábrica, como `awss3.NewBucket`, para devolver una estructura que implementa la interfaz correspondiente.

Todas las funciones de fábrica utilizan tres argumentos: el argumento `scope` en el que se define la construcción (su elemento principal en el árbol de construcciones)`id`, un y `props` un conjunto de key/value pares que la construcción utiliza para configurar los recursos que crea. El patrón del «conjunto de atributos» también se utiliza en otras partes de la AWS CDK.

En Go, los accesorios se representan mediante un tipo de estructura específica para cada constructo. Por ejemplo, `awss3.Bucket` toma un argumento de tipo accesorio `awss3.BucketProps`. Usa una estructura literal para escribir argumentos de utilería.

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

### Estructuras genéricas
<a name="go-generic-structures"></a>

En algunos lugares, la AWS CDK usa JavaScript matrices u objetos sin tipo como entrada a un método. (Consulte, por ejemplo, el método de.) AWS CodeBuild [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) En Go, estos objetos se representan como sectores y una interfaz vacía.

El CDK proporciona diversas funciones auxiliares, como `jsii.Strings`, para crear segmentos que contienen tipos primitivos.

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

### Trabajar con cualquier sector
<a name="go-any-slice"></a>

Algunas construcciones esperan propiedades que sean una lista de varios tipos (tipos de unión en TypeScript). En Go, estos son como una porción de cualquiera (`*[]any`). `any` garantiza que el compilador permita la asignación de diferentes tipos allí. Consulte la documentación de ` [AWS CDK Go package](https://pkg.go.dev/github.com/aws/aws-cdk-go/awscdk/v2) ` para averiguar cuáles son los tipos permitidos.

Para trabajar con estas propiedades, utilice las funciones auxiliares que proporciona `jsii` para crear sectores de cualquier tipo:
+  `jsii.AnySlice` 
+  `jsii.AnyStrings` 
+  `jsii.AnyNumbers` 

Por ejemplo:

```
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"),
  }
})
```

Este enfoque garantiza que el CDK interprete correctamente los segmentos, lo que evita errores de deserialización al implementar o sintetizar las pilas.

### Desarrollo de constructos personalizados
<a name="go-writing-constructs"></a>

En Go, suele ser más sencillo escribir un nuevo constructo que extender uno existente. En primer lugar, defina un nuevo tipo de estructura, incrustando de forma anónima uno o más tipos existentes en caso de que se desee una semántica similar a la de una extensión. Escriba métodos para cualquier funcionalidad nueva que vaya a agregar y los campos necesarios para almacenar los datos que necesite. Defina una interfaz de accesorios si su constructo la necesita. Por último, escriba una función de fábrica `NewMyConstruct()` para devolver una instancia de su constructo.

Si simplemente está cambiando algunos valores predeterminados en un constructo existente o agregando un comportamiento simple en esta instancia, no necesita toda esa configuración. En su lugar, escriba una función de fábrica que invoque a la función de fábrica del constructo que está “extendiendo”. En otros lenguajes de CDK, por ejemplo, puede crear un constructo `TypedBucket` que aplique el tipo de objetos de un bucket de Amazon S3 al anular el tipo `s3.Bucket`, y, en el inicializador del nuevo tipo, añada una política de bucket que solo permita agregar al bucket extensiones de nombre de archivo especificadas. En Go, es más fácil escribir simplemente un `NewTypedBucket` que devuelva un `s3.Bucket` (uso instanciado `s3.NewBucket`) a la que se haya agregado una política de bucket adecuada. No es necesario ningún tipo de constructo nuevo porque la funcionalidad ya está disponible en el constructo de bucket estándar; el nuevo simplemente proporciona una forma más sencilla de configurarlo.

## Construir, sintetizar e implementar
<a name="go-running"></a>

El AWS CDK compila automáticamente la aplicación antes de ejecutarla. Sin embargo, puede resultar útil compilar la aplicación manualmente para comprobar si hay errores y realizar pruebas. Para ello, ejecute `go build` en una línea de comandos solicitados desde el directorio raíz del proyecto.

Para ejecutar las pruebas que haya escrito, use `go test` en la línea de comandos solicitados.

## Resolución de problemas
<a name="go-troubleshooting"></a>

Si se produce un error de compilación como el que aparece a continuación, significa que los segmentos de cadena se han trasladado directamente a una propiedad a la espera de un fragmento de alguno de ellos.

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

Para resolver este error, reemplace `jsii.Strings()` por `jsii.AnyStrings()`. Para obtener más contexto y soluciones adicionales, consulte ` [CDK GitHub issue](https://github.com/aws/aws-cdk/issues/35630) `.