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.

# Fundamentos de la AWS SDK para Rust
<a name="fundamentals"></a>

Aprenda los fundamentos de la programación con: los AWS SDK para Rust aspectos básicos del lenguaje de programación Rust, información sobre el SDK para las cajas de Rust, la configuración del proyecto y el SDK para el uso del entorno de ejecución de Tokio por parte de Rust.

## Requisitos previos
<a name="prerequisites"></a>

Para poder utilizar el AWS SDK para Rust, debes tener Rust y Cargo instalados.
+ Instale la cadena de herramientas de Rust: [https://www.rust-lang. org/tools/install](https://www.rust-lang.org/tools/install)
+ Instale la [herramienta `cargo-component`](https://github.com/bytecodealliance/cargo-component) ejecutando el comando: `cargo install cargo-component`

### Herramientas recomendadas:
<a name="recommended-tools"></a>

Las siguientes herramientas opcionales se pueden instalar en el IDE para facilitar la finalización del código y la solución de problemas.
+ La extensión rust-analyzer, consulte [Rust en Visual Studio Code](https://code.visualstudio.com/docs/languages/rust).
+ Amazon Q Developer, consulte [Instalación de la extensión o el complemento de Amazon Q Developer en el IDE](https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/q-in-IDE-setup.html).

## Aspectos fundamentales de Rust
<a name="rust-fundamentals"></a>

A continuación se presentan algunos conceptos básicos del lenguaje de programación Rust que sería útil conocer. Todas las referencias para obtener más información proceden de [El lenguaje programación Rust](https://doc.rust-lang.org/book/title-page.html#the-rust-programming-language).
+ `Cargo.toml` es el archivo de configuración estándar de proyectos de Rust, que contiene las dependencias y algunos metadatos sobre el proyecto. Los archivos fuente de Rust tienen la extensión de archivo `.rs`. Consulte [¡Hola, Cargo\$1](https://doc.rust-lang.org/book/ch01-03-hello-cargo.html)
  + El archivo `Cargo.toml` se puede personalizar con perfiles; consulte [Personalización de compilaciones con perfiles de versión](https://doc.rust-lang.org/book/ch14-01-release-profiles.html). Estos perfiles no tienen ninguna relación y son independientes AWS del uso que se haga de los perfiles en el AWS `config` archivo compartido. 
  + Una forma habitual de agregar dependencias de biblioteca al proyecto y a este archivo es usar `cargo add`. Consulte [https://doc.rust-lang.org/cargo/commands/cargo-add.html](https://doc.rust-lang.org/cargo/commands/cargo-add.html).
+ Rust tiene una estructura de funciones básica como la que se muestra a continuación. La palabra clave `let` declara una variable y puede combinarse con una asignación (=). Si no especifica ningún tipo después de `let`, el compilador inferirá uno. Consulte [Variables y mutabilidad.](https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html)

  ```
  fn main() {
      let w = "world";
      println!("Hello {}!", w);
  }
  ```
+ Para declarar una variable `x` con un tipo explícito `T`, Rust usa la sintaxis `x: T`. Consulte [Tipos de datos](https://doc.rust-lang.org/book/ch03-02-data-types.html).
+ `struct X {}` define el nuevo tipo `X`. Los métodos se implementan en el tipo de estructura personalizada `X`. Los métodos para el tipo `X` se declaran con bloques de implementación prefijados con la palabra clave `impl`. Dentro del bloque de implementación, `self` se refiere a la instancia de la estructura en la que se llamó el método. Consulte [Palabra clave `impl`](https://doc.rust-lang.org/std/keyword.impl.html) y [Sintaxis de métodos](https://doc.rust-lang.org/book/ch05-03-method-syntax.html).
+ Si es un signo de exclamación (“\$1”) sigue a lo que parece ser una definición de función o una llamada a una función, entonces el código define o llama a una macro. Consulte [Macros](https://doc.rust-lang.org/book/ch19-06-macros.html?highlight=macro#macros).
+ En Rust, los errores irrecuperables se representan mediante la macro `panic!` Cuando un programa encuentra un `panic!`, deja de ejecutarse, imprime un mensaje de error, se deshace, limpia la pila y se cierra. Consulte [Errores irrecuperables con `panic!`](https://doc.rust-lang.org/book/ch09-01-unrecoverable-errors-with-panic.html)
+ Rust no admite la herencia de funciones de clases base como otros lenguajes de programación; los `traits` son la forma en que Rust proporciona la sobrecarga de métodos. Los indicadores pueden considerarse conceptualmente similares a una interfaz. Sin embargo, los indicadores y las interfaces verdaderas tienen diferencias y, a menudo, se utilizan de forma diferente en el proceso de diseño. Consulte [Indicadores: definición del comportamiento compartido](https://doc.rust-lang.org/book/ch10-02-traits.html).
  + El polimorfismo se refiere al código que admite la funcionalidad de varios tipos de datos sin tener que escribir cada uno de ellos de manera individual. Rust admite el polimorfismo mediante enumeraciones, indicadores y genéricos. Consulte [La herencia como sistema de tipos y como código compartido](https://doc.rust-lang.org/book/ch17-01-what-is-oo.html?#inheritance-as-a-type-system-and-as-code-sharing).
+ Rust es muy explícito en cuanto a la memoria. Los indicadores inteligentes “son estructuras de datos que actúan como un indicador, pero también tienen metadatos y capacidades adicionales”. Consulte [Indicadores inteligentes](https://doc.rust-lang.org/book/ch15-00-smart-pointers.html). 
  + El tipo `Cow` es un puntero clone-on-write inteligente que ayuda a transferir la propiedad de la memoria a la persona que llama cuando es necesario. Consulte [https://doc.rust-lang.org/std/borrow/enum.Cow.html](https://doc.rust-lang.org/std/borrow/enum.Cow.html).
  + El tipo `Arc` es un indicador inteligente con recuento de referencias atómico que cuenta las instancias asignadas. Consulte [https://doc.rust-lang.org/std/sync/struct.Arc.html](https://doc.rust-lang.org/std/sync/struct.Arc.html).
+ El SDK de Rust utiliza con frecuencia el patrón generador para crear tipos complejos.

## AWS SDK para Rust crear los fundamentos
<a name="aws-sdk-crate-fundamentals"></a>
+ La caja principal de la funcionalidad del SDK para Rust es `aws-config`. Se incluye en la mayoría de los proyectos porque proporciona la funcionalidad de leer la configuración del entorno.

  ```
  $ cargo add aws-config
  ```
  + No confundas esto con lo Servicio de AWS que se llama AWS Config. Como se trata de un servicio, sigue la convención estándar de Servicio de AWS cajas y se llama`aws-sdk-config`.
+ El SDK para la biblioteca Rust está separado en diferentes cajas de biblioteca por separado Servicio de AWS. Estas cajas están disponibles en [https://docs.rs/](https://docs.rs/).
+ Servicio de AWS Las cajas siguen la convención de nomenclatura de`aws-sdk-[servicename]`, como `aws-sdk-s3` y`aws-sdk-dynamodb`.

## Configuración del proyecto para trabajar con Servicios de AWS
<a name="project-configuration-for-working-with-aws-services"></a>
+ Tendrás que añadir una caja a tu proyecto para cada una de las Servicio de AWS que quieras que utilice tu aplicación.
+ La forma recomendada de agregar una caja es mediante la línea de comandos en el directorio del proyecto, ejecutando `cargo add [crateName]`, por ejemplo `cargo add aws-sdk-s3`.
  + Se agregará una línea al archivo `Cargo.toml` del proyecto en `[dependencies]`.
  + De forma predeterminada, se agregará la última versión de la caja al proyecto.
+ En el archivo fuente, utilice la instrucción `use` para incluir elementos de sus cajas al ámbito. Consulte [Uso de paquetes externos](https://doc.rust-lang.org/book/ch07-04-bringing-paths-into-scope-with-the-use-keyword.html#using-external-packages) en el sitio web del lenguaje de programación Rust.
  + Los nombres de las cajas suelen estar separados con guiones, pero estos se convierten en guiones bajos cuando se utiliza la caja. Por ejemplo, la caja `aws-config` se usa en la instrucción `use` del código como: `use aws_config`.
+ La configuración es un tema complejo. La configuración puede realizarse directamente en el código o especificarse externamente en variables de entorno o archivos de configuración. Para obtener más información, consulte [Configuración externa de clientes de servicio de AWS SDK para Rust](config-external.md).
  + Cuando el SDK carga la configuración, se registran los valores no válidos en lugar de detener la ejecución, ya que la mayoría de las configuraciones tienen valores predeterminados razonables. Para obtener información sobre el registro, consulte [Configuración y uso del registro en AWS SDK de Rust](logging.md).
  + La mayoría de las variables de entorno y los ajustes del archivo de configuración se cargan una vez al iniciarse el programa. Las actualizaciones de los valores no se verán hasta que reinicie el programa.

## Tiempo de ejecución de Tokio
<a name="tokio-runtime"></a>
+ Tokio es un tiempo de ejecución asíncrono para el lenguaje de programación del SDK para Rust, que ejecuta las tareas `async`. Consulte [tokio.rs](http://tokio.rs/) y [docs.rs/tokio](http://docs.rs/tokio).
+ El SDK para Rust requiere un tiempo de ejecución asíncrono. Se recomienda agregar la siguiente caja a los proyectos:

  ```
  $ cargo add tokio --features=full
  ```
+ La macro de atributos `tokio::main` crea un punto de entrada principal asíncrono al programa. Para poder utilizar esta macro, agréguela a la línea anterior al método `main`, como se muestra a continuación:

  ```
  #[tokio::main]
  async fn main() -> Result<(), Error> {
  ```