

O AWS SDK para JavaScript v2 chegou ao fim do suporte. Recomendamos migrar para o [AWS SDK para JavaScript v3](https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/). Para ver detalhes e informações sobre como migrar, consulte este [anúncio](https://aws.amazon.com/blogs/developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/).

# Captura do progresso de rolagem da página da web com Amazon Kinesis

![JavaScript code example that applies to browser execution](https://docs.aws.amazon.com/pt_br/sdk-for-javascript/v2/developer-guide/images/browsericon.png)

**Este exemplo de script do navegador mostra:**
+ Como capturar o progresso de rolagem em uma página da web com o Amazon Kinesis, como exemplo de métricas de uso da página de streaming para análise posterior.

## O cenário
<a name="kinesis-examples-capturing-page-scrolling-scenario"></a>

Neste exemplo, uma página de HTML simples simula o conteúdo de uma página de blog. À medida que o leitor roda o post no blog simulado, o script do navegador usa o para registrar a distância de rolagem vertical da página e envia esses dados para o Kinesis usando o método [`putRecords`](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Kinesis.html#putRecords-property) da classe de cliente Kinesis. Os dados de streaming capturados pelo Amazon Kinesis Data Streams podem ser processados por instâncias do Amazon EC2 e armazenados em qualquer um dos vários datastores, incluindo Amazon DynamoDB e Amazon Redshift.

## Tarefas de pré-requisito
<a name="kinesis-examples-capturing-page-scrolling-prerequisites"></a>

Para configurar e executar este exemplo, você deve primeiro concluir estas tarefas:
+ Crie uma transmissão do Kinesis. Você precisa incluir o ARN do recurso do streaming no script do navegador. Para ter mais informações sobre como criar o Amazon Kinesis Data Streams, consulte [Create and manage Kinesis data streams](https://docs.aws.amazon.com/streams/latest/dev/working-with-streams.html) no *Guia do desenvolvedor do Amazon Kinesis Data Streams*.
+ Crie um banco de identidades do Amazon Cognito com acesso habilitado para identidades não autenticadas. Você precisa incluir o ID do grupo de identidades no código para obter credenciais para o script do navegador. Para obter mais informações, consulte [Grupos de identidade do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/identity-pools.html) no *Guia do desenvolvedor do Amazon Cognito*.
+ Crie um perfil de IAM cuja política conceda permissão para enviar dados a um streaming do Kinesis. Para obter mais informações sobre como criar um perfil do IAM, consulte [Criação de um perfil para delegar permissões a um serviço da AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-service.html) no *Guia do usuário do IAM*.

Use a política de função a seguir ao criar a função do IAM.

------
#### [ JSON ]

****  

```json
{
   "Version":"2012-10-17",		 	 	 
   "Statement": [
      {
         "Effect": "Allow",
         "Action": [
            "mobileanalytics:PutEvents",
            "cognito-sync:*"
         ],
         "Resource": [
            "*"
         ]
      },
      {
         "Effect": "Allow",
         "Action": [
            "kinesis:Put*"
         ],
         "Resource": [
            "arn:aws:kinesis:{{us-east-1:111122223333:stream/stream-name}}"
         ]
      }
   ]
}
```

------

## A página do blog
<a name="kinesis-examples-capturing-page-scrolling-html"></a>

O HTML da página do blog é composto principalmente por uma série de pontos contidos dentro de um elemento `<div>`. A altura rolável desse `<div>` é usada para ajudar a calcular até onde o leitor rolou o conteúdo à medida que lê. O HTML também contém um par de elementos `<script>`. Um desses elementos adiciona o SDK para JavaScript à página e o outro adiciona o script do navegador, que captura o progresso da rolagem na página e o reporta ao Kinesis.

```html
<!DOCTYPE html>
<html>
    <head>
        <title>AWS SDK for JavaScript - Amazon Kinesis Application</title>
    </head>
    <body>
        <div id="BlogContent" style="width: 60%; height: 800px; overflow: auto;margin: auto; text-align: center;">
            <div>
                <p>
                Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum vitae nulla eget nisl bibendum feugiat. Fusce rhoncus felis at ultricies luctus. Vivamus fermentum cursus sem at interdum. Proin vel lobortis nulla. Aenean rutrum odio in tellus semper rhoncus. Nam eu felis ac augue dapibus laoreet vel in erat. Vivamus vitae mollis turpis. Integer sagittis dictum odio. Duis nec sapien diam. In imperdiet sem nec ante laoreet, vehicula facilisis sem placerat. Duis ut metus egestas, ullamcorper neque et, accumsan quam. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos.
                </p>
                <!-- Additional paragraphs in the blog page appear here -->
            </div>
        </div>
        <script src="https://sdk.amazonaws.com/js/aws-sdk-2.283.1.min.js"></script>
        <script src="kinesis-example.js"></script>
    </body>
</html>
```

## Como configurar o SDK
<a name="kinesis-examples-capturing-page-scrolling-configure-sdk"></a>

Obtenha as credenciais necessárias para configurar o SDK chamando o método `CognitoIdentityCredentials`, fornecendo o ID do banco de identidades do Amazon Cognito. Após o sucesso, crie o objeto de serviço do Kinesis na função de retorno de chamada.

O snippet de código a seguir mostra essa etapa. (Consulte [Captura do código do progresso de rolagem da página da web](kinesis-examples-capturing-page-scrolling-full.md) para ver o exemplo completo.)

```javascript
// Configure Credentials to use Cognito
AWS.config.credentials = new AWS.CognitoIdentityCredentials({
  IdentityPoolId: "IDENTITY_POOL_ID",
});

AWS.config.region = "REGION";
// We're going to partition Amazon Kinesis records based on an identity.
// We need to get credentials first, then attach our event listeners.
AWS.config.credentials.get(function (err) {
  // attach event listener
  if (err) {
    alert("Error retrieving credentials.");
    console.error(err);
    return;
  }
  // create Amazon Kinesis service object
  var kinesis = new AWS.Kinesis({
    apiVersion: "2013-12-02",
  });
```

## Criar registros de rolagem
<a name="kinesis-examples-capturing-page-scrolling-create-records"></a>

O progresso de rolagem é calculado usando as propriedades `scrollHeight` e `scrollTop` do `<div>` que contém o conteúdo do post do blog. Cada registro de rolagem é criado em uma função do listener do evento para o evento `scroll` e adicionado a um array de registros para envio periódico ao Kinesis.

O snippet de código a seguir mostra essa etapa. (Consulte [Captura do código do progresso de rolagem da página da web](kinesis-examples-capturing-page-scrolling-full.md) para ver o exemplo completo.)

```javascript
  // Get the ID of the Web page element.
  var blogContent = document.getElementById("BlogContent");

  // Get Scrollable height
  var scrollableHeight = blogContent.clientHeight;

  var recordData = [];
  var TID = null;
  blogContent.addEventListener("scroll", function (event) {
    clearTimeout(TID);
    // Prevent creating a record while a user is actively scrolling
    TID = setTimeout(function () {
      // calculate percentage
      var scrollableElement = event.target;
      var scrollHeight = scrollableElement.scrollHeight;
      var scrollTop = scrollableElement.scrollTop;

      var scrollTopPercentage = Math.round((scrollTop / scrollHeight) * 100);
      var scrollBottomPercentage = Math.round(
        ((scrollTop + scrollableHeight) / scrollHeight) * 100
      );

      // Create the Amazon Kinesis record
      var record = {
        Data: JSON.stringify({
          blog: window.location.href,
          scrollTopPercentage: scrollTopPercentage,
          scrollBottomPercentage: scrollBottomPercentage,
          time: new Date(),
        }),
        PartitionKey: "partition-" + AWS.config.credentials.identityId,
      };
      recordData.push(record);
    }, 100);
  });
```

## Envio de registros para o Kinesis
<a name="kinesis-examples-capturing-page-scrolling-submit-records"></a>

Uma vez a cada segundo, se houver registros na matriz, esses registros pendentes são enviados ao Kinesis.

O snippet de código a seguir mostra essa etapa. (Consulte [Captura do código do progresso de rolagem da página da web](kinesis-examples-capturing-page-scrolling-full.md) para ver o exemplo completo.)

```javascript
  // upload data to Amazon Kinesis every second if data exists
  setInterval(function () {
    if (!recordData.length) {
      return;
    }
    // upload data to Amazon Kinesis
    kinesis.putRecords(
      {
        Records: recordData,
        StreamName: "NAME_OF_STREAM",
      },
      function (err, data) {
        if (err) {
          console.error(err);
        }
      }
    );
    // clear record data
    recordData = [];
  }, 1000);
});
```