Aspectos gerais

Neste laboratório, veremos como migrar o código do Apache Spark para o Cloud Dataproc. Você vai seguir uma sequência de etapas e mover cada vez mais componentes do job para os serviços do Google Cloud:

• Executar o código original do Spark no Cloud Dataproc (migração lift-and-shift)
• Substituir o HDFS pelo Cloud Storage (nativo da nuvem)
• Automatizar tudo para execução em clusters específicos dos jobs (otimizados para a nuvem)

Conteúdo do laboratório

Neste laboratório, você vai aprender a:

• Migrar jobs do Spark para o Cloud Dataproc
• Modificar jobs do Spark para usar o Cloud Storage em vez do HDFS
• Otimizar jobs do Spark para executar em clusters específicos

Vamos usar

• Cloud Dataproc
• Apache Spark

Configuração e requisitos

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

1. Faça login no Qwiklabs em uma janela anônima.

2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
   Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

3. Quando tudo estiver pronto, clique em Começar o laboratório.

4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

5. Clique em Abrir Console do Google.

6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
   Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

7. Aceite os termos e pule a página de recursos de recuperação.

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com 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. No console do Cloud, clique no botão "Abrir o Cloud Shell" na barra de ferramentas superior direita.

   

2. Clique em Continuar.

O provisionamento e a conexão do ambiente podem demorar um pouco. Quando você estiver conectado, já estará autenticado, e o projeto estará definido com seu PROJECT_ID. Exemplo:

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

• Para listar o nome da conta ativa, use este comando:

gcloud auth list

Saída:

Credentialed accounts: - @.com (active)

Exemplo de saída:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Para listar o ID do projeto, use este comando:

gcloud config list project

Saída:

[core] project =

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: a documentação completa da gcloud está disponível no guia com informações gerais sobre a gcloud CLI .

Verifique as permissões do projeto

Antes de começar a trabalhar no Google Cloud, veja se o projeto tem as permissões corretas no Identity and Access Management (IAM).

1. No console do Google Cloud, em Menu de navegação (), selecione IAM e administrador > IAM.

2. Confira se a conta de serviço padrão do Compute {project-number}-compute@developer.gserviceaccount.com está na lista e recebeu o papel de editor. O prefixo da conta é o número do projeto, que está no Menu de navegação > Visão geral do Cloud > Painel.

Observação: se a conta não estiver no IAM ou não tiver o papel de editor, siga as etapas abaixo.

1. No console do Google Cloud, em Menu de navegação, clique em Visão geral do Cloud > Painel.
2. Copie o número do projeto, por exemplo, 729328892908.
3. Em Menu de navegação, clique em IAM e administrador > IAM.
4. Clique em Permitir acesso, logo abaixo de Visualizar por principais na parte de cima da tabela de papéis.
5. Em Novos principais, digite:

{número-do-projeto}-compute@developer.gserviceaccount.com

6. Substitua {project-number} pelo número do seu projeto.
7. Em Papel, selecione Projeto (ou Básico) > Editor.
8. Clique em Save.

Cenário

Você está migrando uma carga de trabalho do Spark para o Cloud Dataproc e modificando o código aos poucos para aproveitar os recursos e serviços nativos do Google Cloud.

Tarefa 1: realizar migração lift-and-shift

Migre jobs do Spark para o Cloud Dataproc

Você criará um cluster do Cloud Dataproc. Depois, executará um notebook do Jupyter importado que usa o Sistema de Arquivos Distribuído do Hadoop (HDFS, na sigla em inglês) padrão do cluster para armazenar os dados de origem. Por fim, você processará esses dados como faria em qualquer cluster do Hadoop, usando o Spark. A atividade demonstra que é possível migrar muitas cargas de trabalho de análise que contêm código do Spark, como os notebooks do Jupyter, para um ambiente do Cloud Dataproc sem alterações.

Configure e inicie um cluster do Cloud Dataproc

1. Na seção Analytics do menu de navegação do console do Google Cloud, clique em Dataproc.

2. Selecione Criar cluster.

3. Clique em Criar para o item Cluster no Compute Engine.

4. Digite sparktodp em Nome do cluster.

5. Defina a região como e a zona como .

6. Na seção Controle de versões, clique em Alterar e selecione 2.1 (Debian 11, Hadoop 3.3, Spark 3.3).

Essa versão inclui Python3, necessário para o exemplo de código usado no laboratório.

7. Clique em Selecionar.

8. Na seção Componentes > Gateway do componente, escolha Ativar gateway de componente.

9. Em Componentes opcionais, selecione Notebook do Jupyter.

10. Na lista Configurar cluster à esquerda, clique em Configurar nós (opcional).

11. Em Nó do administrador, altere Série para E2 e Tipo de máquina para e2-standard-2 (2 vCPUs, 8 GB de memória) e defina o Tamanho do disco principal como 30.

12. Em Nós de trabalho, altere Série para E2 e Tipo de máquina para e2-standard-2 (2 vCPUs, 8 GB de memória) e defina o Tamanho do disco principal para 30.

13. Clique em Criar.

O cluster vai levar uns minutos para iniciar. Espere a implantação do Cloud Dataproc ser concluída e prossiga para a próxima etapa.

Clone o repositório de origem do laboratório

No Cloud Shell, você clona o repositório Git do laboratório e copia os arquivos necessários para o bucket do Cloud Storage que o Cloud Dataproc usa como diretório inicial dos notebooks do Jupyter.

1. Para clonar o repositório do Git do laboratório, digite o seguinte comando no Cloud Shell:

git -C ~ clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Para localizar o bucket padrão do Cloud Storage usado pelo Cloud Dataproc, insira este comando no Cloud Shell:

export DP_STORAGE="gs://$(gcloud dataproc clusters describe sparktodp --region={{{project_0.default_region | REGION }}} --format=json | jq -r '.config.configBucket')"

3. Para copiar os exemplos de notebooks para a pasta de trabalho do Jupyter, insira o seguinte comando no Cloud Shell:

gcloud storage cp ~/training-data-analyst/quests/sparktobq/*.ipynb $DP_STORAGE/notebooks/jupyter

Faça login no notebook do Jupyter

Você já pode acessar as interfaces da Web assim que o cluster terminar de iniciar. Clique no botão "Atualizar" para verificar se a implantação já terminou.

1. Na página "Clusters" do Dataproc, aguarde até que seu cluster termine de iniciar e clique no nome dele para abrir a página Detalhes do cluster.

2. Clique em Interfaces da Web.

3. Clique no link Jupyter para abrir uma nova guia do Jupyter no navegador.

A página inicial do Jupyter será aberta. Nela, é possível conferir o conteúdo do diretório /notebooks/jupyter no Cloud Storage, que inclui os exemplos de notebooks do Jupyter usados no laboratório.

4. Na guia Files, clique na pasta GCS e depois no notebook 01_spark.ipynb para abrir.

5. Clique em Cell e depois em Run All para executar todas as células no notebook.

6. Use Page Up para voltar ao começo do notebook. Acompanhe a execução de cada célula e as respostas que aparecem abaixo delas.

Você pode navegar pelas células e examinar o código que está sendo processado, para ver o que o notebook está fazendo. Preste atenção especialmente ao local em que os dados são salvos e processados.

• A primeira célula de código recupera o arquivo de dados de origem, que é um trecho da competição KDD Cup da conferência Knowledge, Discovery, and Data (KDD) de 1999. Os dados são relacionados a eventos de detecção de intrusões de computador.

!wget https://storage.googleapis.com/cloud-training/dataengineering/lab_assets/sparklab/kddcup.data_10_percent.gz

• Na segunda célula de código, os dados de origem são copiados para o sistema de arquivos padrão do Hadoop (local).

!hadoop fs -put kddcup* /

• Na terceira célula de código, o comando lista o conteúdo do diretório padrão do sistema de arquivos HDFS do cluster.

!hadoop fs -ls /

Leitura dos dados

Os dados são arquivos CSV no formato gzip. No Spark, podemos ler esses arquivos diretamente usando o método textFile e dividir cada linha com vírgulas para fazer a análise.

O código em Python do Spark começa na célula In[4].

• O código desta célula inicializa o Spark SQL, usa o Spark para ler os dados de origem como texto e retorna as cinco primeiras linhas.

from pyspark.sql import SparkSession, SQLContext, Row spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "hdfs:///kddcup.data_10_percent.gz" raw_rdd = sc.textFile(data_file).cache() raw_rdd.take(5)

• Na célula In [5], cada linha é dividida usando , como delimitador e analisada em seguida usando um esquema inline preparado no código.

csv_rdd = raw_rdd.map(lambda row: row.split(",")) parsed_rdd = csv_rdd.map(lambda r: Row( duration=int(r[0]), protocol_type=r[1], service=r[2], flag=r[3], src_bytes=int(r[4]), dst_bytes=int(r[5]), wrong_fragment=int(r[7]), urgent=int(r[8]), hot=int(r[9]), num_failed_logins=int(r[10]), num_compromised=int(r[12]), su_attempted=r[14], num_root=int(r[15]), num_file_creations=int(r[16]), label=r[-1] ) ) parsed_rdd.take(5)

Análise do Spark

Na célula In [6], um contexto do Spark SQL é criado, e um DataFrame do Spark que usa esse contexto é gerado a partir dos dados de entrada analisados na etapa anterior.

1. Os dados das linhas podem ser selecionados e expostos com o método .show() do DataFrame para gerar um resumo da contagem dos campos selecionados:

sqlContext = SQLContext(sc) df = sqlContext.createDataFrame(parsed_rdd) connections_by_protocol = df.groupBy('protocol_type').count().orderBy('count', ascending=False) connections_by_protocol.show()

O método .show() produz uma tabela semelhante à seguinte:

+-------------+------+ |protocol_type| count| +-------------+------+ | icmp|283602| | tcp|190065| | udp| 20354| +-------------+------+

O SparkSQL também pode ser usado para consultar os dados analisados armazenados no DataFrame.

2. Na célula In [7], é registrada uma tabela temporária (connections) que é referenciada na consulta SQL subsequente do SparkSQL:

df.registerTempTable("connections") attack_stats = sqlContext.sql(""" SELECT protocol_type, CASE label WHEN 'normal.' THEN 'no attack' ELSE 'attack' END AS state, COUNT(*) as total_freq, ROUND(AVG(src_bytes), 2) as mean_src_bytes, ROUND(AVG(dst_bytes), 2) as mean_dst_bytes, ROUND(AVG(duration), 2) as mean_duration, SUM(num_failed_logins) as total_failed_logins, SUM(num_compromised) as total_compromised, SUM(num_file_creations) as total_file_creations, SUM(su_attempted) as total_root_attempts, SUM(num_root) as total_root_acceses FROM connections GROUP BY protocol_type, state ORDER BY 3 DESC """) attack_stats.show()

Quando a consulta terminar, você vai receber uma resposta semelhante a este exemplo truncado:

+-------------+---------+----------+--------------+-- |protocol_type| state|total_freq|mean_src_bytes| +-------------+---------+----------+--------------+-- | icmp| attack| 282314| 932.14| | tcp| attack| 113252| 9880.38| | tcp|no attack| 76813| 1439.31| ... ... | udp| attack| 1177| 27.5| +-------------+---------+----------+--------------+--

Também é possível usar gráficos de barras para mostrar esses dados visualmente.

3. O código da última célula, In [8], usa a função mágica do Jupyter %matplotlib inline para redirecionar matplotlib para renderizar uma figura inline no notebook, em vez de apenas jogar os dados em uma variável. Essa célula exibe o gráfico de barras usando a consulta attack_stats da etapa anterior.

%matplotlib inline ax = attack_stats.toPandas().plot.bar(x='protocol_type', subplots=True, figsize=(10,25))

Depois que todas as células no notebook forem executadas, a primeira parte da saída será semelhante ao gráfico abaixo. Role para baixo no seu notebook para conferir o gráfico completo.

Tarefa 2: separar computação e armazenamento

Modifique jobs do Spark para usar o Cloud Storage em vez do HDFS

Usando este exemplo de notebook de "migração lift-and-shift" original, você vai criar uma cópia que separa os requisitos de armazenamento e de computação do job. Nesse caso, basta substituir as chamadas ao sistema de arquivos do Hadoop por chamadas ao Cloud Storage. Para isso, troque as referências a hdfs:// por referências a gs:// no código e faça as mudanças necessárias nos nomes das pastas.

Comece usando o Cloud Shell para colocar uma cópia dos dados de origem em um novo bucket do Cloud Storage.

1. No Cloud Shell, crie um novo bucket de armazenamento para os dados de origem:

export PROJECT_ID=$(gcloud info --format='value(config.project)') gcloud storage buckets create gs://$PROJECT_ID

2. No Cloud Shell, copie os dados de origem para o bucket:

wget https://storage.googleapis.com/cloud-training/dataengineering/lab_assets/sparklab/kddcup.data_10_percent.gz gcloud storage cp kddcup.data_10_percent.gz gs://$PROJECT_ID/

Espere o comando anterior ser concluído e o arquivo ser copiado para o novo bucket.

3. Volte à guia do notebook do Jupyter 01_spark no navegador.

4. Clique em File e em Make a Copy.

5. Quando a cópia abrir, clique no título 01_spark-Copy1 e altere o nome para De-couple-storage.

6. Abra a guia do Jupyter do notebook 01_spark.

7. Clique em File e em Save and checkpoint para salvar o notebook.

8. Clique em File e em Close and Halt para fechar o notebook.

• Se for solicitado, clique em Leave ou em Cancel para confirmar.

9. Volte à guia do notebook do Jupyter De-couple-storage no navegador, se necessário.

Você não precisa mais das células que fazem o download e a cópia dos dados para o sistema de arquivos HDFS interno do cluster, então remova essas células.

Para excluir uma célula, clique nela e depois clique no ícone cut selected cells (símbolo de tesoura) na barra de ferramentas do notebook.

10. Exclua as células de comentário iniciais e as três primeiras células de código ( In [1], In [2] e In [3]) para que o notebook comece com a seção Reading in Data.

Agora você vai alterar o código da primeira célula, que define o local de origem do arquivo de dados e insere os dados de origem. Ela ainda se chama In[4], a menos que você tenha executado o notebook novamente. A célula atualmente contém este código:

from pyspark.sql import SparkSession, SQLContext, Row spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "hdfs:///kddcup.data_10_percent.gz" raw_rdd = sc.textFile(data_file).cache() raw_rdd.take(5)

11. Substitua o conteúdo da célula In [4] pelo código abaixo. A única alteração aqui é criar a variável para armazenar o nome de um bucket do Cloud Storage e apontar data_file para o bucket que usamos para armazenar os dados de origem.

from pyspark.sql import SparkSession, SQLContext, Row gcs_bucket='[Your-Bucket-Name]' spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "gs://"+gcs_bucket+"//kddcup.data_10_percent.gz" raw_rdd = sc.textFile(data_file).cache() raw_rdd.take(5)

Depois que você substituir o código, a primeira célula vai ficar semelhante à imagem abaixo, e o ID do seu projeto do laboratório será o nome do bucket:

12. Na célula atualizada, substitua o marcador de posição [Your-Bucket-Name] pelo nome do bucket de armazenamento que você criou na primeira etapa desta seção. Esse bucket foi criado com o ID do projeto como nome. O ID é mostrado no painel de informações de login do laboratório, no lado esquerdo. Substitua todo o texto do marcador de posição, inclusive os colchetes [].

13. Clique em Cell e depois em Run All para executar todas as células no notebook.

Você vai receber a mesma resposta de quando o arquivo foi carregado e executado no armazenamento interno do cluster. Para mover os arquivos de dados de origem para o Cloud Storage, basta alterar a referência à origem do armazenamento de hdfs:// para gs://.

Tarefa 3: implantar jobs do Spark

Otimize jobs do Spark para executar em clusters específicos

Agora você vai criar um arquivo Python independente para implantação como um job do Cloud Dataproc. Ele terá as mesmas funções deste notebook. Para isso, você adiciona comandos mágicos às células do Python em uma cópia deste notebook para gravar o conteúdo das células em um arquivo. Além disso, você adiciona um manipulador de parâmetros de entrada para definir o local do bucket de armazenamento quando o script em Python é chamado. Isso facilita a portabilidade do código.

1. No menu De-couple-storage do notebook do Jupyter, clique em File e depois em Make a copy.

2. Quando a cópia abrir, clique em De-couple-storage-Copy1 e altere o nome para PySpark-analysis-file.

3. Abra a guia do Jupyter De-couple-storage.

4. Clique em File e em Save and checkpoint para salvar o notebook.

5. Clique em File e em Close and Halt para fechar o notebook.

• Se for solicitado, clique em Leave ou em Cancel para confirmar.

6. Volte à guia do notebook do Jupyter PySpark-analysis-file no navegador, se necessário.

7. Clique na primeira célula na parte superior do notebook.

8. Clique em Insert e selecione Insert Cell Above.

9. Cole o código abaixo na primeira célula de código nova. Ele importa a biblioteca e faz a manipulação dos parâmetros.

%%writefile spark_analysis.py import matplotlib matplotlib.use('agg') import argparse parser = argparse.ArgumentParser() parser.add_argument("--bucket", help="bucket for input and output") args = parser.parse_args() BUCKET = args.bucket

O comando mágico do Jupyter %%writefile spark_analysis.py cria um novo arquivo de resposta para conter o script independente do Python. Você adiciona uma variação dele às demais células para anexar o conteúdo de cada uma ao arquivo de script.

O código também importa o módulo matplotlib e define explicitamente o back-end de plotagem padrão por meio de matplotlib.use('agg'), para que o código de plotagem seja executado fora de um notebook do Jupyter.

10. No início das demais células de código Python, digite %%writefile -a spark_analysis.py. Elas são as cinco células com o rótulo In [x].

%%writefile -a spark_analysis.py

Por exemplo, o código da célula seguinte deve ficar como o indicado abaixo:

%%writefile -a spark_analysis.py from pyspark.sql import SparkSession, SQLContext, Row spark = SparkSession.builder.appName("kdd").getOrCreate() sc = spark.sparkContext data_file = "gs://{}/kddcup.data_10_percent.gz".format(BUCKET) raw_rdd = sc.textFile(data_file).cache() #raw_rdd.take(5)

11. Repita a etapa digitando %%writefile -a spark_analysis.py no início de cada célula de código até chegar ao final.

12. Na última célula, onde um gráfico de barras do Pandas é plotado, remova o comando mágico %matplotlib inline.

Observação: se você não remover a diretiva mágica matplotlib inline do Jupyter, a execução do seu script vai falhar.

13. Selecione a última célula de código no notebook e, na barra de menus, clique em Insert e em Insert Cell Below.

14. Cole o código na célula nova:

%%writefile -a spark_analysis.py ax[0].get_figure().savefig('report.png');

15. Adicione outra célula ao final do notebook e cole este código:

%%writefile -a spark_analysis.py import google.cloud.storage as gcs bucket = gcs.Client().get_bucket(BUCKET) for blob in bucket.list_blobs(prefix='sparktodp/'): blob.delete() bucket.blob('sparktodp/report.png').upload_from_filename('report.png')

16. Adicione uma célula ao final do notebook e cole este código:

%%writefile -a spark_analysis.py connections_by_protocol.write.format("csv").mode("overwrite").save( "gs://{}/sparktodp/connections_by_protocol".format(BUCKET))

Automação de teste

Agora, você vai testar o código PySpark para confirmar que ele é executado corretamente em um arquivo. Chame a cópia local no notebook e passe um parâmetro para identificar o bucket de armazenamento que você criou, que contém os dados de entrada do job. O mesmo bucket será usado para armazenar os arquivos de dados de relatórios produzidos pelo script.

1. No notebook PySpark-analysis-file, adicione uma célula ao final e cole este código:

BUCKET_list = !gcloud info --format='value(config.project)' BUCKET=BUCKET_list[0] print('Writing to {}'.format(BUCKET)) !/opt/conda/miniconda3/bin/python spark_analysis.py --bucket=$BUCKET

Esse código só vai funcionar se você tiver seguido as instruções anteriores e criado um bucket do Cloud Storage usando o ID do seu projeto como o nome. Se você tiver usado outro nome, modifique a variável BUCKET com o nome que você usou.

2. Adicione uma célula ao final do notebook e cole este código:

!gcloud storage ls gs://$BUCKET/sparktodp/**

Esse comando mostra os arquivos de saída do script que foram salvos no seu bucket do Cloud Storage.

3. Para salvar uma cópia do arquivo em Python no armazenamento permanente, adicione uma célula e cole este código:

!gcloud storage cp spark_analysis.py gs://$BUCKET/sparktodp/spark_analysis.py

4. Clique em Cell e depois em Run All para executar todas as células no notebook.

Se o notebook criar e executar um arquivo Python corretamente, você verá uma resposta semelhante à imagem abaixo nas duas últimas células. Isso indica que o script foi executado até o fim e salvou a resposta no bucket do Cloud Storage criado no laboratório.

Observação: a maior causa de erros nessa etapa é a não remoção da diretiva matplotlib em In [7]. Verifique novamente se você modificou todas as células segundo as instruções acima e não pulou nenhuma etapa.

Execute o job de análise no Cloud Shell

1. Volte ao Cloud Shell e copie o script Python do Cloud Storage para executá-lo como um job do Cloud Dataproc:

gcloud storage cp gs://$PROJECT_ID/sparktodp/spark_analysis.py spark_analysis.py

2. Crie um script de inicialização:

nano submit_onejob.sh

3. Cole este código no script:

#!/bin/bash gcloud dataproc jobs submit pyspark \ --cluster sparktodp \ --region {{{project_0.default_region | REGION }}} \ spark_analysis.py \ -- --bucket=$1

4. Pressione CTRL+X, depois Y e Enter para sair e salvar.

5. Torne o script executável:

chmod +x submit_onejob.sh

6. Inicie o job de análise do PySpark:

./submit_onejob.sh $PROJECT_ID

7. Na guia do console do Cloud, acesse Dataproc > Clusters se você ainda não tiver feito isso.

8. Clique em Jobs.

9. Clique no nome do job que aparece na lista. Você pode monitorar o progresso aqui ou no Cloud Shell. Aguarde a conclusão do job.

10. Acesse seu bucket de armazenamento. O relatório gerado, /sparktodp/report.png, terá um carimbo de data/hora atualizado, indicando que o job independente foi realizado.

O bucket que o job usa para gravar dados é o que tem o ID do projeto como nome.

11. Acesse novamente Dataproc > Clusters.

12. Selecione o cluster sparktodp e clique em Excluir. Você não precisa mais dele.

13. Clique em CONFIRMAR.

14. Feche as guias do Jupyter no seu navegador.

Finalize o laboratório

Clique em Terminar o laboratório após a conclusão. O Google Cloud Ensina remove os recursos usados e limpa a conta por você.

Você vai poder avaliar sua experiência no laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.

O número de estrelas indica o seguinte:

• 1 estrela = muito insatisfeito
• 2 estrelas = insatisfeito
• 3 estrelas = neutro
• 4 estrelas = satisfeito
• 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.

Copyright 2020 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.