**Apresentando uma nova experiência de console para AWS WAF**
Agora você pode usar a experiência atualizada para acessar a AWS WAF funcionalidade em qualquer lugar do console. Para obter mais detalhes, consulte [Trabalhando com o console](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Exemplos de código para o SDK AWS WAF móvel
Esta seção fornece exemplos de código para uso do SDK móvel.
## Inicialização do provedor de tokens e obtenção de tokens
Você inicia sua instância do provedor de token usando um objeto de configuração. Em seguida, você pode recuperar tokens usando as operações disponíveis. Veja a seguir os componentes básicos do código necessário.
------
#### [ iOS ]
```
let url: URL = URL(string: "protection pack (web ACL) integration URL")!
let configuration = WAFConfiguration(applicationIntegrationUrl: url, domainName: "Domain name")
let tokenProvider = WAFTokenProvider(configuration)
//onTokenReady can be add as an observer for UIApplication.willEnterForegroundNotification
self.tokenProvider.onTokenReady() { token, error in
if let token = token {
//token available
}
if let error = error {
//error occurred after exhausting all retries
}
}
//getToken()
let token = tokenProvider.getToken()
```
------
#### [ Android ]
Exemplo de Java:
```
String applicationIntegrationURL = "protection pack (web ACL) integration URL";
//Or
URL applicationIntegrationURL = new URL("protection pack (web ACL) integration URL");
String domainName = "Domain name";
WAFConfiguration configuration = WAFConfiguration.builder().applicationIntegrationURL(applicationIntegrationURL).domainName(domainName).build();
WAFTokenProvider tokenProvider = new WAFTokenProvider(Application context, configuration);
// implement a token result callback
WAFTokenResultCallback callback = (wafToken, error) -> {
if (wafToken != null) {
// token available
} else {
// error occurred in token refresh
}
};
// Add this callback to application creation or activity creation where token will be used
tokenProvider.onTokenReady(callback);
// Once you have token in token result callback
// if background refresh is enabled you can call getToken() from same tokenprovider object
// if background refresh is disabled you can directly call getToken()(blocking call) for new token
WAFToken token = tokenProvider.getToken();
```
Exemplo de Kotlin:
```
import com.amazonaws.waf.mobilesdk.token.WAFConfiguration
import com.amazonaws.waf.mobilesdk.token.WAFTokenProvider
private lateinit var wafConfiguration: WAFConfiguration
private lateinit var wafTokenProvider: WAFTokenProvider
private val WAF_INTEGRATION_URL = "protection pack (web ACL) integration URL"
private val WAF_DOMAIN_NAME = "Domain name"
fun initWaf() {
// Initialize the tokenprovider instance
val applicationIntegrationURL = URL(WAF_INTEGRATION_URL)
wafConfiguration =
WAFConfiguration.builder().applicationIntegrationURL(applicationIntegrationURL)
.domainName(WAF_DOMAIN_NAME).backgroundRefreshEnabled(true).build()
wafTokenProvider = WAFTokenProvider(getApplication(), wafConfiguration)
// getToken from tokenprovider object
println("WAF: "+ wafTokenProvider.token.value)
// implement callback for where token will be used
wafTokenProvider.onTokenReady {
wafToken, sdkError ->
run {
println("WAF Token:" + wafToken.value)
}
}
}
```
------
## Permitindo que o SDK forneça o cookie de token em suas solicitações HTTP
Se `setTokenCookie` é `TRUE`, o provedor de token inclui o cookie de token para você em suas solicitações da web para todos os locais no caminho especificado em `tokenCookiePath`. Por padrão, `setTokenCookie` é `TRUE` e `tokenCookiePath` é `/`.
Você pode restringir o escopo das solicitações que incluem um cookie de token especificando o caminho do cookie de token, por exemplo, `/web/login`. Se você fizer isso, verifique se suas AWS WAF regras não inspecionam os tokens nas solicitações que você envia para outros caminhos. Ao usar o grupo de regras `AWSManagedRulesACFPRuleSet`, você configura os caminhos de registro e criação da conta, e o grupo de regras verifica os tokens nas solicitações enviadas para esses caminhos. Para saber mais, consulte [Adicionando o grupo de regras gerenciadas do ACFP à sua web ACL](waf-acfp-rg-using.md). Da mesma forma, ao usar o grupo de regras `AWSManagedRulesATPRuleSet`, você configura o caminho de login e o grupo de regras verifica os tokens nas solicitações enviadas para esse caminho. Para obter mais informações, consulte [Adicionar grupos de regras gerenciadas ao pacote de proteção (ACL da Web)](waf-atp-rg-using.md).
------
#### [ iOS ]
Quando `setTokenCookie` é`TRUE`, o provedor de token armazena o AWS WAF token em um `HTTPCookieStorage.shared` e inclui automaticamente o cookie nas solicitações para o domínio que você especificou`WAFConfiguration`.
```
let request = URLRequest(url: URL(string: domainEndpointUrl)!)
//The token cookie is set automatically as cookie header
let task = URLSession.shared.dataTask(with: request) { data, urlResponse, error in
}.resume()
```
------
#### [ Android ]
Quando `setTokenCookie` estiver`TRUE`, o provedor de token armazena o AWS WAF token em uma `CookieHandler` instância que é compartilhada em todo o aplicativo. O provedor de token inclui automaticamente o cookie nas solicitações para o domínio que você especificou em `WAFConfiguration`.
Exemplo de Java:
```
URL url = new URL("Domain name");
//The token cookie is set automatically as cookie header
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
connection.getResponseCode();
```
Exemplo de Kotlin:
```
val url = URL("Domain name")
//The token cookie is set automatically as cookie header
val connection = (url.openConnection() as HttpsURLConnection)
connection.responseCode
```
Se você já tiver a instância padrão `CookieHandler` inicializada, o provedor de token a usará para gerenciar cookies. Caso contrário, o provedor de token inicializará uma nova `CookieManager` instância com o AWS WAF token `CookiePolicy.ACCEPT_ORIGINAL_SERVER` e, em seguida, definirá essa nova instância como a instância padrão em`CookieHandler`.
O código a seguir mostra como o SDK inicializa o gerenciador e o manipulador de cookies quando eles não estão disponíveis no seu aplicativo.
Exemplo de Java:
```
CookieManager cookieManager = (CookieManager) CookieHandler.getDefault();
if (cookieManager == null) {
// Cookie manager is initialized with CookiePolicy.ACCEPT_ORIGINAL_SERVER
cookieManager = new CookieManager();
CookieHandler.setDefault(cookieManager);
}
```
Exemplo de Kotlin:
```
var cookieManager = CookieHandler.getDefault() as? CookieManager
if (cookieManager == null) {
// Cookie manager is initialized with CookiePolicy.ACCEPT_ORIGINAL_SERVER
cookieManager = CookieManager()
CookieHandler.setDefault(cookieManager)
}
```
------
## Fornecimento manual do cookie de token em suas solicitações HTTP
Se você definir `setTokenCookie` como `FALSE`, precisará fornecer o cookie de token manualmente, como um cabeçalho de solicitação HTTP de cookie, em suas solicitações para seu endpoint protegido. O código a seguir mostra como fazer isso.
------
#### [ iOS ]
```
var request = URLRequest(url: wafProtectedEndpoint)
request.setValue("aws-waf-token=token from token provider", forHTTPHeaderField: "Cookie")
request.httpShouldHandleCookies = true
URLSession.shared.dataTask(with: request) { data, response, error in }
```
------
#### [ Android ]
Exemplo de Java:
```
URL url = new URL("Domain name");
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
String wafTokenCookie = "aws-waf-token=token from token provider";
connection.setRequestProperty("Cookie", wafTokenCookie);
connection.getInputStream();
```
Exemplo de Kotlin:
```
val url = URL("Domain name")
val connection = (url.openConnection() as HttpsURLConnection)
val wafTokenCookie = "aws-waf-token=token from token provider"
connection.setRequestProperty("Cookie", wafTokenCookie)
connection.inputStream
```
------