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.
# Configuración de proxies de HTTP
Puede configurar proxies de HTTP mediante código, definiendo propiedades del sistema Java o definiendo variables de entorno.
## Configuración en código
Los proxies se configuran en código con un generador `ProxyConfiguration` específico del cliente al crear el cliente de servicio. El siguiente código muestra un ejemplo de configuración de proxy para un cliente Apache-based HTTP que utiliza un cliente del servicio Amazon S3.
```
SdkHttpClient httpClient1 = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://proxy.example.com"))
.username("username")
.password("password")
.addNonProxyHost("localhost")
.build())
.build();
S3Client s3Client = S3Client.builder()
.httpClient(httpClient)
.build();
```
En la sección correspondiente a cada cliente HTTP de este tema se muestra un ejemplo de configuración de proxy.
+ [Cliente HTTP basado en Apache](http-configuration-apache.md#http-configuration-apache-proxy-conf-ex)
+ [URLConnection-based Cliente HTTP ](http-configuration-url.md#http-configuration-url-proxy-conf-ex)
+ [Netty-based Cliente HTTP ](http-configuration-netty.md#http-config-netty-proxy-ex)
+ [AWS CRT-based Cliente HTTP ](http-configuration-crt.md#http-config-crt-proxy-ex)
## Configuración de proxies de HTTP con ajustes externos
Aunque no utilice explícitamente un compilador de `ProxyConfiguration` en el código, el SDK busca ajustes externos para configurar una configuración de proxy predeterminada.
De forma predeterminada, el SDK busca primero las propiedades del sistema JVM. Si se encuentra una sola propiedad, el SDK usa el valor y cualquier otro valor de propiedad del sistema. Si no hay propiedades del sistema disponibles, el SDK busca variables de entorno del proxy.
El SDK puede usar las siguientes propiedades y variables de entorno del sistema Java.
**Propiedades del sistema Java**
| Propiedad del sistema | Description (Descripción) | Compatibilidad con clientes HTTP |
| --- | --- | --- |
| http.proxyHost | Nombre de host del servidor proxy HTTP | Todos |
| http.proxyPort | Número de puerto del servidor proxy HTTP | Todos |
| http.proxyUser | Nombre de usuario para la autenticación mediante proxy HTTP | Todos |
| http.proxyPassword | Contraseña para la autenticación mediante proxy HTTP | Todos |
| http.non ProxyHosts | Lista de hosts a los que se debe acceder directamente, sin pasar por el proxy. [Esta lista también es válida cuando se utiliza HTTPS](https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html). | Todos |
| https.proxyHost | Nombre de host del servidor proxy HTTP | Netty, CRT |
| https.proxyPort | Número de puerto del servidor proxy HTTP | Netty, CRT |
| https.proxyUser | Nombre de usuario para la autenticación mediante proxy HTTPS | Netty, CRT |
| https.proxyPassword | Contraseña para la autenticación mediante proxy HTTPS | Netty, CRT |
**Variables de entorno**
| Variable de entorno | Description (Descripción) | Compatibilidad con clientes HTTP |
| --- | --- | --- |
| HTTP\_PROXY1 | URL válida con un esquema de HTTP | Todos |
| HTTPS\_PROXY1 | URL válida con un esquema de HTTPS | Netty, CRT |
| NO\_PROXY2 | Lista de hosts a los que se debe acceder directamente, sin pasar por el proxy. La lista es válida tanto para HTTP como para HTTPS. | Todos |
### Visualización de notas clave y al pie
**Todos**: todos los clientes HTTP que ofrece el SDK: `UrlConnectionHttpClient`, `ApacheHttpClient`, `NettyNioAsyncHttpClient`, `AwsCrtAsyncHttpClient`.
**Netty**: el cliente Netty-based HTTP (). `NettyNioAsyncHttpClient`
**CRT**: los clientes AWS CRT-based HTTP, (`AwsCrtHttpClient`y`AwsCrtAsyncHttpClient`).
1La variable de entorno consultada, ya sea `HTTP_PROXY` o `HTTPS_PROXY`, depende de la configuración del esquema en la `ProxyConfiguration` del cliente. El esquema predeterminado es HTTP. El siguiente fragmento de código muestra cómo cambiar el esquema a HTTPS utilizado para la resolución de variables de entorno.
```
SdkHttpClient httpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.scheme("https")
.build())
.build();
```
2La variable de entorno `NO_PROXY` admite una combinación de separadores “\|” y “,” entre los nombres de host. Para ver los formatos comodín compatibles, consulte. [comportamiento no ProxyHosts comodín](#http-config-proxy-nonproxyhosts-behavior)
## Uso de una combinación de ajustes
Puede usar una combinación de ajustes de proxy de HTTP en el código, las propiedades del sistema y las variables de entorno.
**Example – configuración proporcionada por una propiedad del sistema y por código.**
```
// Command line with the proxy password set as a system property.
$ java -Dhttp.proxyPassword=SYS_PROP_password -cp ... App
// Since the 'useSystemPropertyValues' setting is 'true' (the default), the SDK will supplement
// the proxy configuration in code with the 'http.proxyPassword' value from the system property.
SdkHttpClient apacheHttpClient = ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.endpoint(URI.create("http://localhost:1234"))
.username("username")
.build())
.build();
// Use the apache HTTP client with proxy configuration.
DynamoDbClient dynamoDbClient = DynamoDbClient.builder()
.httpClient(apacheHttpClient)
.build();
```
El SDK resuelve la siguiente configuración del proxy.
```
Host = localhost
Port = 1234
Password = SYS_PROP_password
UserName = username
Non ProxyHost = null
```
**Example – están disponibles tanto las propiedades del sistema como las variables de entorno**
El compilador `ProxyConfiguration` del cliente de HTTP ofrece configuraciones denominadas `useSystemPropertyValues` y `useEnvironmentVariablesValues`. De forma predeterminada, ambas configuraciones son `true`. Cuando es `true`, el SDK utiliza automáticamente valores de propiedades del sistema o variables de entorno para las opciones que no proporciona el compilador `ProxyConfiguration`.
Las propiedades del sistema tienen prioridad sobre las variables de entorno. Si se encuentra una propiedad del sistema proxy de HTTP, el SDK recupera ***todos*** los valores de las propiedades del sistema y ninguno de las variables de entorno. Si desea priorizar las variables de entorno sobre las propiedades del sistema, establezca `useSystemPropertyValues` en `false`.
En este ejemplo, los siguientes ajustes están disponibles en tiempo de ejecución:
```
// System properties
http.proxyHost=SYS_PROP_HOST.com
http.proxyPort=2222
http.password=SYS_PROP_PASSWORD
http.user=SYS_PROP_USER
// Environment variables
HTTP_PROXY="http://EnvironmentUser:EnvironmentPassword@ENV_VAR_HOST:3333"
NO_PROXY="environmentnonproxy.host,environmentnonproxy2.host:1234"
```
El cliente de servicio se crea con una de las instrucciones siguientes. Ninguna de las instrucciones establece explícitamente una configuración de proxy.
```
DynamoDbClient client = DynamoDbClient.create();
DynamoDbClient client = DynamoDbClient.builder().build();
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.build())
.build())
.build();
```
El SDK resuelve la siguiente configuración del proxy.
```
Host = SYS_PROP_HOST.com
Port = 2222
Password = SYS_PROP_PASSWORD
UserName = SYS_PROP_USER
Non ProxyHost = null
```
Dado que el cliente de servicio tiene la configuración de proxy predeterminada, el SDK busca las propiedades del sistema y, a continuación, las variables de entorno. Puesto que la configuración de las propiedades del sistema tiene prioridad sobre las variables de entorno, el SDK utiliza únicamente las propiedades del sistema.
Si el uso de las propiedades del sistema se cambia a `false`, como se muestra en el código siguiente, el SDK resuelve solo las variables de entorno.
```
DynamoDbClient client = DynamoDbClient.builder()
.httpClient(ApacheHttpClient.builder()
.proxyConfiguration(ProxyConfiguration.builder()
.useSystemPropertyValues(Boolean.FALSE)
.build())
.build())
.build();
```
La configuración de proxy resuelta mediante HTTP es:
```
Host = ENV_VAR_HOST
Port = 3333
Password = EnvironmentPassword
UserName = EnvironmentUser
Non ProxyHost = environmentnonproxy.host, environmentnonproxy2.host:1234
```
## comportamiento no ProxyHosts comodín
Con`nonProxyHosts`, puede especificar los hosts que omiten el proxy. Establezca este valor mediante el `ProxyConfiguration` generador, la propiedad `http.nonProxyHosts` del sistema o la variable de `NO_PROXY` entorno. Cada fuente admite los siguientes formatos de entrada.
+ **Anfitrión exacto**: `example.com` (coincide solo con el anfitrión especificado)
+ **Comodín inicial**: `*.example.com` (coincide con el dominio y todos los subdominios)
+ **Comodín simple**: `*` (omite todos los hosts)
+ **Intervalo CIDR**: `10.0.0.0/8` (coincide con todas las direcciones IP del intervalo)
### Diferencias de comportamiento entre los clientes HTTP
El tipo de cliente HTTP y la fuente de entrada afectan a dos comportamientos de coincidencia importantes.
#### Comparación de las entradas del generador con las configuraciones externas
Cuando se proporcionan entradas comodín (`*.example.com`o`*`) mediante los `addNonProxyHost(String)` métodos `nonProxyHosts(Set)` o del `ProxyConfiguration` generador, los caracteres comodín solo funcionan con los clientes AWS CRT-based HTTP (`AwsCrtHttpClient`y`AwsCrtAsyncHttpClient`).
Los clientes URLConnection basados en ApacheNetty, y arrojan un `PatternSyntaxException` par de entradas comodín que se proporcionan a través del generador.
Cuando las entradas provienen de la propiedad del `http.nonProxyHosts` sistema o de la variable de `NO_PROXY` entorno, los comodines funcionan con todos los clientes.
**importante**
Si necesita caracteres comodín para todos los clientes HTTP, utilice la propiedad del `http.nonProxyHosts` sistema o la variable de `NO_PROXY` entorno en lugar del generador.
#### Root-domain hacer coincidir las entradas comodín iniciales
Los AWS CRT-based clientes y los demás clientes HTTP gestionan el `*.example.com` patrón de forma diferente:
+ **CRT-based clientes**: `*.example.com` coincide tanto con el dominio raíz (`example.com`) como con los subdominios (por ejemplo,`api.example.com`).
+ **ApacheNetty, y clientes URLConnection basados**: solo `*.example.com` coincide con los subdominios. El dominio raíz `example.com` no coincide y el SDK lo enruta a través del proxy.
### Resumen del comportamiento de los comodines por fuente de entrada
En la tabla siguiente se resume el comportamiento de las coincidencias cuando se proporcionan entradas mediante la propiedad del `http.nonProxyHosts` sistema o la variable de `NO_PROXY` entorno. Todos los clientes admiten caracteres comodín de estas fuentes.
| Formato de entrada | Non-CRT clientes (ApacheNetty, yURLConnection) | CRT-based clientes |
| --- | --- | --- |
| Anfitrión exacto (`example.com`) | Honrado | Honrado |
| Comodín principal () `*.example.com` | Aceptado (solo subdominios) | Homologado (dominio raíz y subdominios) |
| Comodín puro () `*` | Honrado | Honrado |
| Gama CIDR () `10.0.0.0/8` | Honrado | Honrado |