GSP642

Informações gerais

Há 12 anos, Lilian fundou a rede de clínicas veterinárias Pet Theory. A Pet Theory teve rápida expansão nos últimos anos. Entretanto, o antigo sistema de agendamento de consultas não consegue dar conta do aumento da demanda. Por isso, Lilian está pedindo para você criar um sistema baseado na nuvem com uma escalonabilidade melhor do que a oferecida pela solução legada.

A equipe de operações da Pet Theory é formada por apenas uma pessoa, o Pedro. Assim, o cliente precisa de uma solução que não exija muita manutenção contínua. A equipe optou pela tecnologia sem servidor.

Raquel foi contratada como consultora para ajudar a Pet Theory a fazer a transição para um ambiente sem servidor. Depois de comparar as opções de banco de dados sem servidor, a equipe decide adotar o Cloud Firestore. Como o Firestore opera sem servidor, não é necessário provisionar capacidade previamente, e isso implica que não há risco de ultrapassar os limites de armazenamento ou de operações. O Firestore mantém os dados sincronizados em todos os apps cliente por meio de listeners em tempo real e oferece suporte off-line para dispositivos móveis e Web, de modo que seja possível criar apps responsivos que funcionem de maneira independente da latência da rede ou da conectividade com a internet.

Neste laboratório, você ajudará Pedro a fazer upload dos dados atuais da Pet Theory para um banco de dados do Cloud Firestore. Para realizar essa tarefa, ele trabalhará lado a lado com Raquel.

Arquitetura

Este diagrama mostra uma visão geral dos serviços que você vai usar e como eles se conectam:

Objetivos

Neste laboratório, você vai aprender a:

• Configurar o Firestore no Google Cloud
• Criar um código de importação de banco de dados
• Gerar uma coleção de dados dos clientes para teste
• Importar os dados de teste dos clientes para o Firestore

Pré-requisitos

Este é um laboratório de nível introdutório, que pressupõe experiência com o console do Cloud e os ambientes shell. A experiência com o Firebase será útil, mas não é obrigatória.

Você também precisa estar familiarizado com a edição de arquivos. Use seu editor de texto favorito (como o nano, o vi etc.) ou inicie o editor de código do Cloud Shell, disponível na barra de cima:

Quando estiver tudo pronto, role a tela para baixo e siga as etapas para configurar o ambiente do laboratório.

Configuração e requisitos

Antes de clicar no botão Start Lab

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você vai encontrar o seguinte:

   • O botão Abrir console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Nome de usuário"}}}

   Você também encontra o Nome de usuário no painel Detalhes do laboratório.

4. Clique em Seguinte.

5. Copie a Senha abaixo e cole na caixa de diálogo de boas-vindas.

   {{{user_0.password | "Senha"}}}

   Você também encontra a Senha no painel Detalhes do laboratório.

6. Clique em Seguinte.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: clique em Menu de navegação no canto superior esquerdo para acessar uma lista de produtos e serviços do Google Cloud.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

2. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = <project_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Tarefa 1: configurar o Firestore no Google Cloud

A tarefa de Pedro é fazer o upload dos dados da Pet Theory para um banco de dados do Cloud Firestore. Para alcançar essa meta, ele trabalhará lado a lado com Raquel. Raquel recebe uma mensagem de Pedro na TI...

Pedro, administrador de TI	Oi, Raquel O primeiro passo na transição para um ambiente sem servidor é criar um banco de dados do Firestore com o Google Cloud. Você pode me ajudar com essa tarefa? Não sei muito bem como fazer essa configuração. Pedro
Raquel, consultora de software	Olá, Pedro, Claro, é um prazer ajudar você com isso. Vou enviar alguns recursos para você começar. Voltamos a conversar sobre isso assim que você terminar a criação do banco de dados. Raquel

Ajude Pedro a configurar um banco de dados do Firestore usando o console do Cloud.

1. No console do Cloud, acesse o menu de navegação e selecione Firestore.

2. Clique em + Criar banco de dados.

3. Selecione a opção Modo nativo e clique em Continuar.

Observação: ambos os modos apresentam alto desempenho com consistência forte, mas têm aparência diferente e são otimizados para diferentes casos de uso.

• O Modo Nativo é útil para permitir que vários usuários acessem simultaneamente os mesmos dados. Além disso, ele tem recursos como atualizações em tempo real e conexão direta entre seu banco de dados e um cliente da Web/para dispositivos móveis.
• O Modo Datastore destaca a alta capacidade de processamento (grande quantidade de leituras e gravações).

4. No menu suspenso Região, selecione a região e clique em Criar banco de dados.

Depois de concluir a tarefa, Raquel envia um e-mail a Pedro...

Raquel, consultora de software	Olá, Pedro, Excelente trabalho de configuração do banco de dados do Firestore! Para gerenciar o acesso ao banco de dados, usaremos uma conta de serviço que tenha sido criada automaticamente com os privilégios necessários. Agora estamos prontos para migrar do banco de dados antigo para o Firestore. Raquel
Pedro, administrador de TI	Olá, Raquel, Obrigado pela ajuda. Configurar o banco de dados do Firestore foi simples. Espero que o processo de importação do banco de dados seja mais fácil do que foi com o banco de dados legado, que é bastante complexo e exige a realização de muitas etapas. Pedro

Tarefa 2: criar um código de importação de banco de dados

O novo banco de dados do Cloud Firestore está pronto para uso, mas está vazio. Os dados dos clientes da Pet Theory ainda estão apenas no banco de dados antigo.

Pedro envia uma mensagem a Raquel...

Pedro, administrador de TI	Oi, Raquel, Meu gerente quer começar a migrar os dados de clientes para o novo banco de dados do Firestore. Eu exportei um arquivo CSV do banco de dados legado, mas não está claro para mim como fazer para importar esses dados para o Firestore. Você pode me dar uma mão? Pedro
Raquel, consultora de software	Olá, Pedro, Claro. Vamos marcar uma reunião para discutir o que precisa ser feito. Raquel

Como Pedro disse, os dados dos clientes estarão disponíveis em um arquivo CSV. Ajude Pedro a criar um aplicativo que lê os registros dos clientes de um arquivo CSV e grava esses registros no Firestore. Como Pedro conhece JavaScript, crie esse aplicativo com o ambiente de execução JavaScript Node.js.

1. No Cloud Shell, execute o comando a seguir para clonar o repositório da Pet Theory:

git clone https://github.com/rosera/pet-theory

2. Use o editor de código do Cloud Shell (ou o editor da sua preferência) para alterar os arquivos. Na barra de cima da sessão do Cloud Shell, clique em Abrir editor. Uma nova guia será aberta. Se uma mensagem aparecer, clique em Abrir em uma nova janela para abrir o editor de código:

3. Em seguida, troque o diretório de trabalho atual por lab01:

cd pet-theory/lab01

No diretório, é possível conferir o package.json de Pedro. Esse arquivo lista os pacotes que são dependências do projeto Node.js. Com ele, é possível reproduzir o build e compartilhá-lo com outras pessoas.

Mostramos abaixo um exemplo de package.json:

{ "name": "lab01", "version": "1.0.0", "description": "This is lab01 of the Pet Theory labs", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "Patrick - IT", "license": "MIT", "dependencies": { "csv-parse": "^5.5.3" } }

Agora que Pedro já importou o código-fonte, ele entra em contato com Raquel para saber quais pacotes são necessários para a migração.

Pedro, administrador de TI	Oi, Raquel, O código que usei para o banco de dados legado é bem básico, ele apenas cria um arquivo CSV pronto para o processo de importação. Preciso fazer o download de algo antes de começar? Pedro
Raquel, consultora de software	Oi, Pedro, Eu sugiro usar um dos muitos pacotes @google-cloud do Node para interagir com o Firestore. Então, devemos fazer apenas pequenas alterações ao código, já que o trabalho pesado já foi feito. Raquel

Para que o código de Pedro grave no banco de dados do Firestore, você precisa instalar algumas dependências de pares.

4. Para isso, execute o seguinte comando:

npm install @google-cloud/firestore

5. Para que o app possa gravar registros no Cloud Logging, instale mais um módulo:

npm install @google-cloud/logging

Após a conclusão do comando, o package.json será automaticamente atualizado para incluir as novas dependências de pares e será semelhante à sequência abaixo.

... "dependencies": { "@google-cloud/firestore": "^7.3.0", "@google-cloud/logging": "^11.0.0", "csv-parse": "^5.5.3" }

Agora é hora de dar uma olhada no script que lê o arquivo CSV de clientes e grava um registro no Firestore para cada linha do arquivo CSV. O aplicativo original de Pedro é mostrado abaixo:

const csv = require('csv-parse'); const fs = require('fs'); function writeToDatabase(records) { records.forEach((record, i) => { console.log(`ID: ${record.id} Email: ${record.email} Name: ${record.name} Phone: ${record.phone}`); }); return ; } async function importCsv(csvFilename) { const parser = csv.parse({ columns: true, delimiter: ',' }, async function (err, records) { if (e) { console.error('Error parsing CSV:', e); return; } try { console.log(`Call write to Firestore`); await writeToDatabase(records); console.log(`Wrote ${records.length} records`); } catch (e) { console.error(e); process.exit(1); } }); await fs.createReadStream(csvFilename).pipe(parser); } if (process.argv.length < 3) { console.error('Please include a path to a csv file'); process.exit(1); } importCsv(process.argv[2]).catch(e => console.error(e));

Ele importa a resposta do arquivo CSV de entrada para o banco de dados legado. A seguir, atualize esse código para gravar no Firestore.

6. Abra o arquivo pet-theory/lab01/importTestData.js.

Para fazer referência à API Firestore por meio do aplicativo, é preciso adicionar a dependência de pares à base de código.

7. Adicione a dependência do Firestore a seguir na linha 3 do arquivo:

const { Firestore } = require("@google-cloud/firestore");

O início do arquivo precisa ter este código:

const csv = require('csv-parse'); const fs = require('fs'); const { Firestore } = require("@google-cloud/firestore"); // Add this

A integração com o banco de dados do Firestore pode ser feita com algumas linhas de código. Exatamente com esse objetivo, Raquel compartilhou um modelo de código com você e Pedro.

8. Adicione o código a seguir abaixo da linha 34 ou após a condicional if (process.argv.length < 3):

async function writeToFirestore(records) { const db = new Firestore({ // projectId: projectId }); const batch = db.batch() records.forEach((record)=>{ console.log(`Write: ${record}`) const docRef = db.collection("customers").doc(record.email); batch.set(docRef, record, { merge: true }) }) batch.commit() .then(() => { console.log('Batch executed') }) .catch(err => { console.log(`Batch error: ${err}`) }) return }

O snippet de código acima declara um novo objeto de banco de dados, que faz referência ao banco de dados criado anteriormente no laboratório. A função usa um processamento em lote no qual cada registro é processado, um de cada vez, e recebe uma referência de documento com base no identificador adicionado. No final da função, o conteúdo do lote é gravado (commit) no banco de dados.

9. Na função importCsv, adicione a chamada a writeToFirestore e remova a chamada a writeToDatabase. Ele será parecido com o seguinte:

async function importCsv(csvFilename) { const parser = csv.parse({ columns: true, delimiter: ',' }, async function (err, records) { if (err) { console.error('Error parsing CSV:', err); return; } try { console.log(`Call write to Firestore`); await writeToFirestore(records); // await writeToDatabase(records); console.log(`Wrote ${records.length} records`); } catch (e) { console.error(e); process.exit(1); } }); await fs.createReadStream(csvFilename).pipe(parser); }

10. Adicione geração de registros ao aplicativo. Para fazer referência à API Logging por meio do aplicativo, adicione a dependência de pares à base de código. Adicione a linha a seguir logo abaixo das outras instruções "require", no início do arquivo:

const { Logging } = require('@google-cloud/logging');

O início do arquivo precisa ter este código:

const csv = require('csv-parse'); const fs = require('fs'); const { Firestore } = require("@google-cloud/firestore"); const { Logging } = require('@google-cloud/logging');

11. Adicione algumas variáveis constantes e inicialize o cliente do Logging. Adicione essas constantes logo abaixo das linhas acima no arquivo (em torno da linha 5), da seguinte maneira:

const logName = "pet-theory-logs-importTestData"; // Creates a Logging client const logging = new Logging(); const log = logging.log(logName); const resource = { type: "global", };

12. Adicione o código para gravar os registros na função importCsv logo abaixo da linha "console.log(Wrote ${records.length} records);", que deve ser semelhante ao seguinte:

// Uma entrada de registro em texto success_message = `Success: importTestData - Wrote ${records.length} records`; const entry = log.entry( { resource: resource }, { message: `${success_message}` } ); log.write([entry]);

Depois dessas mudanças, o bloco de código da função importCsv deve ficar assim:

async function importCsv(csvFilename) { const parser = csv.parse({ columns: true, delimiter: ',' }, async function (err, records) { if (err) { console.error('Error parsing CSV:', err); return; } try { console.log(`Call write to Firestore`); await writeToFirestore(records); // await writeToDatabase(records); console.log(`Wrote ${records.length} records`); // A text log entry success_message = `Success: importTestData - Wrote ${records.length} records`; const entry = log.entry( { resource: resource }, { message: `${success_message}` } ); log.write([entry]); } catch (e) { console.error(e); process.exit(1); } }); await fs.createReadStream(csvFilename).pipe(parser); }

Agora, quando o código do aplicativo for executado, o banco de dados do Firestore será atualizado com o conteúdo do arquivo CSV. A função importCsv recebe um nome de arquivo e analisa o conteúdo linha a linha. Cada linha processada é agora enviada para a função do Firestore writeToFirestore, em que cada novo registro é gravado no banco de dados de "clientes".

Observação: em um ambiente de produção, você vai criar um script de importação próprio.

Tarefa 3: criar dados de teste

Está na hora de importar alguns dados! Pedro entra em contato com Raquel para falar sobre uma preocupação dele com a execução de um teste com dados reais de clientes...

Pedro, administrador de TI	Oi, Raquel, Acho que seria melhor não usarmos os dados de clientes para os testes. Precisamos preservar a privacidade do cliente, mas também precisamos estar seguros de que nosso script de importação de dados funciona corretamente. Você consegue pensar em um método de teste alternativo? Pedro
Raquel, consultora de software	Olá, Pedro, Bem lembrado, Pedro. Essa é uma questão complicada, já que os dados dos clientes podem incluir informações de identificação pessoal, também chamadas de PII. Vou compartilhar com você um código inicial para criar dados de um pseudocliente. Poderemos usar esses dados para testar o script de importação. Raquel

Ajude Pedro a instalar e colocar em operação esse gerador de dados pseudoaleatórios.

1. Em primeiro lugar, instale a biblioteca "faker", que será usada pelo script que gera os dados de clientes fictícios. Execute o comando a seguir para atualizar a dependência em package.json:

npm install faker@5.5.3

2. Agora abra o arquivo chamado createTestData.js com o editor de código e inspecione o código. Ele deve ser semelhante a:

const fs = require('fs'); const faker = require('faker'); function getRandomCustomerEmail(firstName, lastName) { const provider = faker.internet.domainName(); const email = faker.internet.email(firstName, lastName, provider); return email.toLowerCase(); } async function createTestData(recordCount) { const fileName = `customers_${recordCount}.csv`; var f = fs.createWriteStream(fileName); f.write('id,name,email,phone\n') for (let i=0; i<recordCount; i++) { const id = faker.datatype.number(); const firstName = faker.name.firstName(); const lastName = faker.name.lastName(); const name = `${firstName} ${lastName}`; const email = getRandomCustomerEmail(firstName, lastName); const phone = faker.phone.phoneNumber(); f.write(`${id},${name},${email},${phone}\n`); } console.log(`Created file ${fileName} containing ${recordCount} records.`); } recordCount = parseInt(process.argv[2]); if (process.argv.length != 3 || recordCount < 1 || isNaN(recordCount)) { console.error('Include the number of test data records to create. Example:'); console.error(' node createTestData.js 100'); process.exit(1); } createTestData(recordCount);

3. Adicione a geração de registros para a base de código. Na linha 3, adicione a seguinte referência ao módulo da API Logging do código do aplicativo:

const { Logging } = require("@google-cloud/logging");

O início do arquivo deve ficar assim:

const fs = require("fs"); const faker = require("faker"); const { Logging } = require("@google-cloud/logging"); //adicione isto

4. Agora adicione algumas variáveis constantes e inicialize o cliente do Logging. Adicione este código logo abaixo das instruções const:

const logName = "pet-theory-logs-createTestData"; // Creates a Logging client const logging = new Logging(); const log = logging.log(logName); const resource = { // This example targets the "global" resource for simplicity type: "global", };

5. Adicione o código para gravar os registros na função createTestData logo abaixo da linha "console.log(Created file ${fileName} containing ${recordCount} records.);" que será semelhante a:

// A text log entry const success_message = `Success: createTestData - Created file ${fileName} containing ${recordCount} records.`; const entry = log.entry( { resource: resource }, { name: `${fileName}`, recordCount: `${recordCount}`, message: `${success_message}`, } ); log.write([entry]);

6. Depois da atualização, o bloco de código da função createTestData deve ser semelhante ao seguinte:

async function createTestData(recordCount) { const fileName = `customers_${recordCount}.csv`; var f = fs.createWriteStream(fileName); f.write('id,name,email,phone\n') for (let i=0; i<recordCount; i++) { const id = faker.datatype.number(); const firstName = faker.name.firstName(); const lastName = faker.name.lastName(); const name = `${firstName} ${lastName}`; const email = getRandomCustomerEmail(firstName, lastName); const phone = faker.phone.phoneNumber(); f.write(`${id},${name},${email},${phone}\n`); } console.log(`Created file ${fileName} containing ${recordCount} records.`); // A text log entry const success_message = `Success: createTestData - Created file ${fileName} containing ${recordCount} records.`; const entry = log.entry( { resource: resource }, { name: `${fileName}`, recordCount: `${recordCount}`, message: `${success_message}`, } ); log.write([entry]); }

7. Execute o comando a seguir no Cloud Shell para criar o arquivo customers_1000.csv, que conterá mil registros de dados de teste:

node createTestData 1000

A saída ficará assim:

Created file customers_1000.csv containing 1000 records.

8. Abra o arquivo customers_1000.csv e verifique se os dados de teste foram criados.

Teste a tarefa concluída

Clique em Verificar meu progresso para conferir a tarefa realizada. Se você tiver criado com êxito uma amostra de dados de teste para o banco de dados do Firestore, verá uma pontuação de avaliação.

Crie dados de teste para o banco de dados do Firestore

Tarefa 4: importar os dados de teste dos clientes

1. Para testar a capacidade de importação, use o script de importação e os dados de teste criados previamente:

node importTestData customers_1000.csv

A saída ficará assim:

Writing record 500 Writing record 1000 Wrote 1000 records

2. Se você receber uma mensagem de erro que se assemelhe ao seguinte:

Error: Cannot find module 'csv-parse'

Execute o comando a seguir para adicionar o pacote csv-parse ao seu ambiente:

npm install csv-parse

3. Em seguida, execute o comando novamente. Você vai receber esta saída:

Writing record 500 Writing record 1000 Wrote 1000 records

Nas últimas seções, você observou como Pedro e Raquel criaram dados de teste e um script para importar dados para o Firestore. Pedro agora está mais confiante para carregar dados de clientes no banco de dados do Firestore.

Teste a tarefa concluída

Clique em Verificar meu progresso para conferir a tarefa realizada. Se você importou com êxito os dados de teste para o banco de dados do Firestore, verá uma pontuação de avaliação.

Importe dados de teste para o banco de dados do Firestore

Tarefa 5: inspecionar os dados no Firestore

Com sua ajuda e com a ajuda da Raquel, Pedro agora migrou os dados de teste para o banco de dados do Firestore. Abra o Firestore e confira os resultados!

1. Volte à guia do console do Cloud. No Menu de navegação, clique em Firestore. Em seguida, clique no ícone de lápis.

2. Digite /customers e pressione Enter.

3. Atualize a guia do navegador. A seguinte lista de clientes migrados será exibida:

Parabéns!

Durante este laboratório, você recebeu treinamento prático com o Firestore. Depois de gerar uma coleção de dados de clientes para teste, você executou um script que importou os dados para o Firestore. Você aprendeu a lidar com dados no Firestore por meio do console do Cloud.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 28 de fevereiro de 2024

Laboratório testado em 28 de fevereiro de 2024

Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.