> ## Documentation Index
> Fetch the complete documentation index at: https://br.developers.hubspot.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Introdução aos módulos

> Crie um componente reutilizável em suas páginas e modelos chamado módulo personalizado. Você aprenderá sobre campos e os usará com o HubL.

'Crie um componente reutilizável em suas páginas e modelos chamado módulo personalizado. Você aprenderá sobre campos e os usará com o HubL.';

'[https://cdn2.hubspot.net/hubfs/327485/Module%20Editor-1-1.png](https://cdn2.hubspot.net/hubfs/327485/Module%20Editor-1-1.png)';

Neste tutorial, você usará o tema do HubSpot CMS Boilerplate para aprender como criar um módulo e usá-lo em modelos e páginas como parte de um tema. No final do tutorial, você terá criado um módulo de depoimentos que inclui um campo de imagem, um campo de texto e um campo de rich text.

<Alert type="tip">
  Se esta é a sua primeira experiência com o desenvolvimento do CMS Hub, recomendamos:

  <CTA id="28bfd0e9-ec05-48a5-b069-ce20015f54ac" label="Início rápido no desenvolvimento do CMS Hub" />
</Alert>

<Alert type="info" titleText="Observação:">
  Se você estiver procurando desenvolver um módulo para uso em um tema que deseja listar no Asset Marketplace da HubSpot, confira os [requisitos de módulo do Asset Marketplace](https://developers.hubspot.com/docs).
</Alert>

## Antes de começar

Antes de começar com este tutorial:

* Configure um [Ambiente de testes para desenvolvedores do HubSpot CMS](https://offers.hubspot.com/free-cms-developer-sandbox). Você pode usar sua conta existente, mas o ambiente de testes permitirá o desenvolvimento sem afetar os ativos da sua conta principal.
* Instale o[ Node.js](https://nodejs.org/en/), que habilita as ferramentas de desenvolvimento local da HubSpot. As versões 10 ou superior são compatíveis.

Se quiser avançar, você pode visualizar os [arquivos do projeto](https://github.com/HubSpot/cms-modules-getting-started/tree/3b9159334f8c6204c7d2d34d8945d71b6ba402ea) concluídos. Como o código do tema do CMS Boilerplate pode mudar com o tempo, apenas os arquivos mais críticos que os desenvolvedores precisarão criar ou editar durante o tutorial são incluídos. Esses campos incluem:

1. **Testimonial.module:** a pasta que contém os arquivos que compõem o módulo personalizado que você criará como parte do tutorial.
2. **homepage.html:** o modelo que será editado para incluir o módulo personalizado.
3. **images:** a pasta que contém as imagens de perfil que você usará no módulo.

## Configurar seu ambiente de desenvolvimento local

Durante este tutorial, você fará o desenvolvimento do módulo localmente. Para interagir com o HubSpot na interface da linha de comando, você precisará instalar a [CLI do HubSpot](/developer-tooling/local-development/hubspot-cli/install-the-cli) e configurá-la para acessar sua conta.

* No terminal, execute o comando a seguir para instalar a CLI globalmente. Para instalar a CLI apenas no seu diretório atual, execute o `npm install @hubspot/cli`.

```shell theme={null}
npm install -g @hubspot/cli
```

* No diretório onde você armazenará os arquivos do tema, autentique a sua conta da HubSpot para que seja possível interagir com ela por meio da CLI.

```shell theme={null}
hs account auth
```

* Pressione **Enter** para abrir a página da chave de acesso pessoal no navegador.
* Selecione a **conta** para a qual deseja implantar e clique em **Continuar com esta conta**. Você será redirecionado para a página da chave de acesso pessoal da conta.
* Ao lado de *Chave de acesso pessoal*, clique em **Mostrar** para revelar sua chave. Em seguida, clique em **Copiar** para copiá-la para a área de transferência.
* Cole a chave copiada no terminal e pressione **Enter**.
* Insira um **nome** exclusivo para a conta. Esse nome só será visto e usado por você ao executar comandos. Em seguida, pressione **Enter**. Para conectar as ferramentas de desenvolvimento local à sua conta:

Você verá uma mensagem de sucesso confirmando que o arquivo `~/.hscli/config.yml` foi criado.

## Adicionar o CMS Boilerplate à sua conta

* Execute o comando abaixo para criar um novo tema chamado `my-theme`. Uma pasta de temas chamada `my-theme` será criada no seu diretório de trabalho contendo os ativos de boilerplate.

```shell theme={null}
hs create website-theme my-theme
```

* Carregue os arquivos na sua conta.

```shell theme={null}
hs upload <src> <destination>
```

| Parâmetro | Descrição                                                                     |
| --------- | ----------------------------------------------------------------------------- |
|           | O caminho para os arquivos locais, em relação ao diretório de trabalho atual. |
|           | O caminho de destino na sua conta HubSpot. Isso pode ser uma nova pasta.      |

Por exemplo, `hs upload my-theme my-new-theme` faria o upload da pasta `my-theme` do seu computador para uma pasta `my-new-theme` no HubSpot.

<Alert type="info">
  Por padrão, o HubSpot carregará na conta padrão no seu arquivo `hubspot.config,yml`. No entanto, você também pode especificar uma conta, incluindo o sinalizador `--account=<accountNameOrId>` no comando. Por exemplo, `hs upload --portal=mainProd`.

  Saiba mais na [Referência de comando da CLI](/developer-tooling/local-development/hubspot-cli/install-the-cli).
</Alert>

## Criar um módulo no HubSpot

Com o boilerplate de CMS em seu ambiente local, você criará um novo módulo para o tema.

<Alert type="info">
  Para os fins deste tutorial, você criará o módulo no HubSpot e o aplicará ao tema usando a CLI. No entanto, você também pode criar módulos do zero localmente usando o comando [hs create module](/developer-tooling/local-development/hubspot-cli/install-the-cli).
</Alert>

* Faça login na sua conta da HubSpot e acesse o gerenciador de design, navegando até **Marketing > Arquivos e modelos > Ferramentas de design**.

* Na barra lateral esquerda do gerenciador de design, abra a **pasta de temas** que você acabou de fazer o upload.

* Na pasta de temas, abra a pasta de **módulos**.

* No canto superior esquerdo, clique em \*\*Arquivo > Novo arquivo \*\*para criar um novo módulo nesta pasta.

* Na caixa de diálogo, clique no **menu suspenso**, selecione **Módulo** e clique em **Próximo**.

  ![new-module-dropdown-menu0](https://br.hubspot.com/hubfs/Knowledge_Base_2021/Developer/new-module-dropdown-menu0.png)

* Marque a caixa de seleção **Páginas** para disponibilizar o módulo para o site e as landing pages.

* Nomeie o módulo como **Depoimentos** e clique em **Criar**.

### Adicionar campos ao módulo

Em seguida, você adicionará três campos ao módulo:

* Um campo de texto para armazenar o nome do cliente que está fornecendo o depoimento.
* Um campo de imagem que armazenará a imagem de perfil do cliente.
* Um campo de rich text que armazenará o depoimento do cliente.

#### Adicionar campo de texto para nome do cliente

* Na barra lateral direita do editor de módulos, clique no menu suspenso \*\*Adicionar campo \*\*e selecione **Texto**.

  ![testimonial-module-add-field](https://br.hubspot.com/hubfs/Knowledge_Base_2023/testimonial-module-add-field.png)

* Na barra lateral direita, clique no **ícone de lápis** no canto superior direito para dar um nome para o campo. Para este tutorial, insira o **Nome do cliente**. Você verá a mudança do nome da variável do HubL para **customer\_name**.

* Defina o **Texto padrão** para **Sally**.

![Exemplo de campo de texto](https://cdn2.hubspot.net/hubfs/53/Text-Field-3.png)

* Na barra lateral direita, clique no ícone de **trilha de navegação** para retornar ao menu do módulo principal.

![module-breadcrumb-icon0](https://br.hubspot.com/hubfs/Knowledge_Base_2021/Developer/module-breadcrumb-icon0.png)

#### Adicionar o campo de imagem para a foto de perfil do cliente

* Adicione outro campo usando o mesmo método, desta vez, selecionando o tipo de campo de **Imagem**.
* Rotule o campo de imagem **Imagem do perfil**, em seguida, defina o **nome da variável do HubL** como **profile\_pic**.
* Em **Imagem padrão**, selecione a imagem do perfil fornecida para Sally na pasta de **imagens** dos [arquivos do projeto](https://github.com/HubSpot/cms-modules-getting-started/tree/3b9159334f8c6204c7d2d34d8945d71b6ba402ea/images) concluídos.
* Defina o **Texto alternativo** como **Imagem de perfil de Sally**.

![getting-started-with-modules-profile-pic](https://br.hubspot.com/hubfs/Knowledge_Base_2023/getting-started-with-modules-profile-pic.png)

#### Adicionar o campo de rich text para o depoimento de Sally

* Adicione outro campo usando o mesmo método, desta vez selecionando o tipo de campo de **Rich text**.
* Rotule o campo de rich text **Depoimentos**.
* Clique na caixa de **Rich text padrão** e digite "Não tive nada além de experiências maravilhosas com esta empresa."

![Exemplo de campo de rich text](https://cdn2.hubspot.net/hubfs/53/Rich-Text-Field-5--.png)

Até agora, você adicionou dados em vários campos de módulo. Neste momento, porém, o módulo não contém nenhum HTML para renderizar esses dados. No editor do módulo, isso é refletido pelo estado vazio da seção `module.html`. ![module-html-empty0](https://br.hubspot.com/hubfs/Knowledge_Base_2021/Developer/module-html-empty0.png)

Em seguida, você adicionará o HubL ao `module.html` para exibir os dados do campo.

### Adicionar o HubL para exibir os dados de campo

Para exibir dados dos campos criados anteriormente, adicione o seguinte HubL ao painel `module.html`:

```hubl theme={null}
<!-- module.html -->
{{module.customer_name}}
<img src={{module.profile_pic.src}} alt="{{module.profile_pic.alt}}">
{{module.testimonial}}
```

Os tokens HubL acima usam notação de ponto para acessar os dados de cada campo. Nesse caso, como queremos extrair os dados dos campos do módulo, cada token começa com `module`, seguido pelo nome da variável HubL do campo. Você pode usar a notação de ponto para acessar ainda mais propriedades específicas de um campo, o que você pode ver nos tokens `profile_pic` na linha 3 acima.

* Com o HubL adicionado ao módulo, clique em **Visualizar** no canto superior direito para ver como o módulo está até agora.

![design-manager-previewer](https://br.hubspot.com/hubfs/Knowledge_Base_2023/design-manager-previewer.png)

* No canto superior direito, clique em **Publicar alterações**.

Depois de criar e publicar o módulo no HubSpot, você usará a CLI para enviá-lo para o ambiente local, de modo a poder visualizar seu conteúdo e fazer quaisquer alterações necessárias.

## Exibir e modificar o módulo localmente

Para exibir o módulo localmente, primeiro você precisará baixá-lo para o tema local:

* No terminal, execute o seguinte comando: `hs fetch <hs_src> <destination>`:

  * `<hs_src>` representa o caminho do arquivo do módulo no HubSpot. Para obter o caminho do arquivo, clique com o botão direito do mouse no módulo, na barra lateral esquerda do gerenciador de design, e selecione **Copiar caminho**.

    ![design-manager-copy-path0](https://br.hubspot.com/hubfs/Knowledge_Base_2021/Developer/design-manager-copy-path0.png)

  * `<destination>` representa o caminho para o diretório local onde se encontra o tema. Se omitido, o comando será o padrão para o diretório de trabalho atual.

Por exemplo, se você já estiver no diretório de trabalho, o comando de busca pode ser semelhante ao seguinte:

```shell theme={null}
hs fetch my-theme/modules/testimonial.module
```

### Abrir a pasta do módulo no seu ambiente local

No seu editor de códigos preferido, acesse a pasta do módulo que você acabou de baixar da sua conta da HubSpot. Dentro da pasta do módulo, você verá cinco arquivos diferentes:

| Parâmetro     | Descrição                                                   |
| ------------- | ----------------------------------------------------------- |
| `fields.json` | Um objeto JSON que contém os campos do módulo.              |
| `meta.json`   | Um objeto JSON que contém metainformações sobre seu módulo. |
| `module.css`  | O arquivo CSS que estiliza o módulo.                        |
| `module.html` | O HTML e o HubL do seu módulo.                              |
| `module.js`   | O JavaScript do seu módulo.                                 |

Você pode encontrar informações mais detalhadas em nossa documentação sobre a [estrutura de arquivos do módulo](https://developers.hubspot.com/docs), principalmente as relacionadas aos arquivos `fields.json` e `meta.json`. Neste tutorial, vamos nos concentrar nos arquivos `fields.json`, `module.css` e `module.html` e como eles são gerados, baixados e enviados para o editor de módulos no Gerenciador de design.

### Exibir o arquivo fields.json do módulo

Abra o arquivo `fields.json` do módulo. Além de alguns dos números de `id`, o atributo `src` do campo de imagem e, potencialmente, a ordem dos campos, o arquivo deve conter um objeto JSON semelhante ao seguinte:

```json theme={null}
//fields.json

[
  {
    "label": "Customer Name",
    "name": "customer_name",
    "id": "2a025cd5-7357-007f-ae2f-25ace762588e",
    "type": "text",
    "required": true,
    "locked": false,
    "validation_regex": "",
    "allow_new_line": false,
    "show_emoji_picker": false,
    "default": "Sally"
  },
  {
    "label": "Profile Picture",
    "name": "profile_pic",
    "id": "7877fb84-eb8a-d2c7-d939-77e6e9557d8f",
    "type": "image",
    "required": false,
    "locked": false,
    "responsive": true,
    "resizable": true,
    "default": {
      "src": "https://cdn2.hubspotqa.net/hubfs/101140939/profile-pic-sally.svg",
      "alt": "Sally Profile Picture",
      "width": 100,
      "height": 100,
      "max_width": 100,
      "max_height": 100
    }
  },
  {
    "label": "Testimonial",
    "name": "testimonial",
    "id": "c5524ece-1ab5-f92d-a5de-e2bf53199dfa",
    "type": "richtext",
    "required": false,
    "locked": false,
    "default": "<p>I’ve had nothing but wonderful experiences with this company.</p>"
  }
]
```

Os valores para os seguintes campos corresponderão aos valores adicionados na etapa 3:

* `name`: o nome do campo.
* `label`: o rótulo do campo.
* `default`: o valor padrão do campo.

### Exibir o arquivo module.html do módulo

O arquivo `module.html`deve conter o HubL e o HTML que você escreveu anteriormente no editor de módulos do HubL + HTML.

Para tornar este código mais interessante e pronto para estilo CSS, copie e cole o seguinte código no arquivo:

```hubl theme={null}
<div class="testimonial">
  <h1 class="testimonial__header"> {{ module.customer_name }} </h1>
  <img class="testimonial__picture" src={{ module.profile_pic.src }} alt={{ module.profile_pic.alt }}>
  {{ module.testimonial }}
</div>
```

<Alert type="info">
  Escrever seu HTML, como mostrado acima, usa a [estrutura de classes BEM](https://css-tricks.com/bem-101/) de acordo com o [guia de estilo](https://github.com/HubSpot/cms-theme-boilerplate/blob/main/STYLEGUIDE.md#css-code-formatting) do tema do HubSpot CMS Boilerplate.
</Alert>

### Exibir o arquivo module.css do módulo

O arquivo `module.css` deve estar vazio neste momento. Para adicionar estilo, copie e cole o seguinte código no arquivo:

```css theme={null}
.testimonial {
  text-align: center;
}

.testimonial__header {
  font-weight: bold;
}

.testimonial__picture {
  display: block;
  margin: auto;
}
```

Após adicionar o código, salve o arquivo.

## As alterações locais para a sua conta da HubSpot

Depois de salvar as alterações locais, envie-as à sua conta da HubSpot.

* Acesse o terminal e verifique se você está no diretório correto.
* Execute o comando watch para enviar alterações para o HubSpot ao salvar: `hs watch <src> <destination>`.

```shell theme={null}
hs watch my-theme my-theme
```

## Visualizar suas alterações locais no HubSpot

* Na sua conta da HubSpot, vá em **Marketing** > **Arquivos e Modelos** > **Ferramentas de design**.
* Na barra lateral esquerda, acesse o **tema** que você criou, abra a pasta de **módulos** e selecione o módulo **Depoimentos**.
* Com o módulo aberto, você deve ver suas alterações nos painéis `module.html` e `module.css`
* No canto superior direito, clique em **Visualizar**. Uma nova guia será aberta para exibir a visualização do módulo.

![Exemplo de visualização do módulo](https://cdn2.hubspot.net/hubfs/53/Module-Preview-7.png)

Recapitulando este tutorial até agora, você:

* criou um módulo no HubSpot.
* Baixou esse módulo para o seu ambiente local.
* Fez alterações no HubL + HTML e CSS usando suas ferramentas de desenvolvimento local.

Na próxima parte deste tutorial, saiba como usar o módulo em um modelo.

## Adicionar o módulo a um modelo

Para esta parte do tutorial, você trabalhará principalmente dentro das pastas `modules` e `templates` nos arquivos de tema locais. ![theme-folder-structure-getting-started-with-modules0](https://br.hubspot.com/hubfs/Knowledge_Base_2021/Developer/theme-folder-structure-getting-started-with-modules0.png)

Por sua definição mais básica, os módulos são áreas editáveis de modelos e páginas da HubSpot. Você pode inserir módulos em modelos no HubSpot usando o gerenciador de design, mas aqui usaremos o HubL para adicionar módulos a um modelo em seu ambiente local.

* No editor de código, abra a pasta `templates` e, em seguida, abra o arquivo `home.html`.

* No arquivo `home.html`, acesse a `dnd_section` final, que começa na linha 28. Você adicionará o seu novo módulo a esta seção.

  ![home-html-add-testimonial-module-to-section0](https://br.hubspot.com/hubfs/Knowledge_Base_2021/Developer/home-html-add-testimonial-module-to-section0.png)

* Em `dnd_section` e acima dos outros `dnd_modules`, copie e cole a seguinte tag de módulo HubL:

```hubl theme={null}
{% dnd_module
 path= “../modules/Testimonial.module”,
 offset=0,
 width=4
%}
{% end_dnd_module %}
```

Essa tag HubL faz referência ao seu novo módulo pelo caminho relativo de arquivo. Para que o módulo se ajuste de forma uniforme aos outros dois módulos na `dnd_section`, também atribui valores de `width` e `offset` ao módulo:

* O CMS da HubSpot usa um [sistema de grade de 12 colunas](https://developers.hubspot.com/docs#columns); portanto, para espaçar este módulo de forma uniforme com os outros dois, você precisará atualizar a `dnd_section` de cada módulo para uma largura igual a `4`.
* Em seguida, o primeiro `dnd_module` no grupo (`testimonial`) terá um deslocamento de `0` para posicioná-lo primeiro em lugar.
* O segundo `dnd_module` (`linked_image`) terá um deslocamento de `4` para posicioná-lo em segundo lugar.
* O terceiro `dnd_module` (`rich_text`) terá um deslocamento de `8` para posicioná-lo em terceiro lugar.

Depois de definir `offset` e `width` para cada `dnd_module`, seu código será semelhante ao seguinte:

```hubl theme={null}
{% dnd_section
    background_color="#f8fafc",
    vertical_alignment="MIDDLE"
  %}

    {% dnd_module
      path= “../modules/Testimonial.module”,
      offset=0,
      width=4
    %}
    {% end_dnd_module %}

    {% dnd_module
      path="@hubspot/linked_image",
      img={
        "alt": "Stock placeholder image with grayscale geometrical mountain landscape",
        "loading": "lazy",
        "max_height": 451,
        "max_width": 605,
        "size_type": "auto_custom_max",
        "src": get_asset_url("../images/grayscale-mountain.png")
      },
      offset=4,
      width=4
    %}
    {% end_dnd_module %}
    {% dnd_module
      path="@hubspot/rich_text",
      html="<h2>Provide more details here.</h2><p>Use text and images to tell your company’s story. Explain what makes your product or service extraordinary.</p>"
      offset=8,
      width=4
    %}
    {% end_dnd_module %}
  {% end_dnd_section %}
```

<Alert type="info">
  Ao adicionar um módulo a uma área de arrastar e soltar, a tag do módulo <u>não</u> exige um nome exclusivo. No entanto, ao adicionar um módulo a um arquivo HTML fora das áreas de arrastar e soltar, você deve atribuir ao módulo um nome exclusivo. Você também usaria uma sintaxe ligeiramente diferente, por exemplo:

  `{% module "testimonial_one" path="../modules/Testimonial.module" %}`

  Saiba mais sobre como [usar módulos em modelos](/cms/reference/modules/using-modules-in-templates).
</Alert>

## Visualizar suas alterações no HubSpot

* Se você não tiver mantido o comando `watch` em execução para rastrear seu trabalho automaticamente, execute `hs watch <src> <dest>`. Certifique-se de que esse comando continue em execução ao concluir as próximas etapas.
* Na sua conta da HubSpot, abra o gerenciador de design (**Marketing** > **Arquivos e modelos** > **Ferramentas de design**.
* Na barra lateral esquerda do gerenciador de design, selecione o arquivo **home.html**.
* No canto superior direito, clique em **Visualizar** e selecione **Visualização em tempo real com opções de exibição** para abrir a visualização do modelo em uma nova janela.

![Exemplo de visualização em tempo real](https://cdn2.hubspot.net/hubfs/53/Live-Preview-10.png)

* Na nova guia, confira a visualização do modelo, que deve conter o módulo de depoimentos recém-adicionado.

![testimonial-module-added-to-theme](https://br.hubspot.com/hubfs/Knowledge_Base_2023/testimonial-module-added-to-theme.png)

## Personalizar o módulo no modelo localmente

Para tornar o modelo da página inicial mais interessante:

* Retorne ao editor de códigos e abra o arquivo `home.html`.
* Adicione os seguintes parâmetros à tag do módulo de depoimentos:

```hubl theme={null}
{% dnd_module
 path='../modules/Testimonial.module',
 customer_name = "Mary",
 profile_pic = {
  src: "{{
   get_asset_url('../images/profile-pic-mary.svg') }}",
   alt: "Mary Profile Picture"
   },
 testimonial = "Wow, what a product! I can't wait to recommend this to all my family and friends!",
 offset=0,
 width=4
%}
{% end_dnd_module %}
```

Os parâmetros acima substituem os valores padrão que você atribuiu originalmente aos três campos. Cada parâmetro usa o nome da variável do HubL que você atribuiu a cada campo anteriormente:

* `customer_name`**:** este parâmetro passa o nome `Mary` para o campo de nome do cliente, substituindo o valor de `Sally`.
* `profile_pic`\*\*: \*\*este parâmetro é um objeto que contém duas propriedades.
  * A propriedade `src` usa a função do HubL `get_asset_url` para recuperar o URL da nova imagem de perfil. Observe que o caminho do arquivo de imagem é relativo ao seu diretório de trabalho. Primeiro, você precisará adicionar essa imagem à pasta `images` nos arquivos do tema local. Você pode encontrar a imagem na pasta `images` nos[arquivos do projeto concluído.](https://github.com/HubSpot/cms-modules-getting-started/tree/3b9159334f8c6204c7d2d34d8945d71b6ba402ea/images)
  * A propriedade `alt` atribui o texto alternativo da imagem.
* `testimonial`**:** este parâmetro passa um novo texto para o campo de depoimentos.

Alternativamente, para o campo de rich text, você pode usar a sintaxe de bloco do HubL para escrever um grande bloco de HTML ou texto:

```hubl theme={null}
{% dnd_module
 path='../modules/Testimonial.module',
 customer_name = "Mary",
 profile_pic = {
  src: "{{
   get_asset_url('../images/profile-pic-mary.svg') }}",
   alt: "Mary Profile Picture"
   },
 offset=0,
 width=4
%}
 {% module_attribute "testimonial" %}
   Wow, what a product! I can't wait to recommend this to all my family and friends!
 {% end_module_attribute %}
{% end_dnd_module %}
```

Saiba mais sobre a [sintaxe de bloco do módulo](/cms/reference/modules/using-modules-in-templates).

Se você manteve o comando `watch` em execução no seu terminal, salve as alterações para enviá-las para o HubSpot. Você pode voltar ao gerenciador de design para visualizar o modelo.

![Módulo Mary em modelos](https://cdn2.hubspot.net/hubfs/53/Mary-Module-in-Template-12.png)

## Adicionar mais dois módulos de depoimentos ao modelo

Nesta etapa, você adicionará mais dois módulos de depoimentos ao modelo usando as mesmas etapas anteriores:

* Acesse o editor de códigos e, em seguida, abra o arquivo `home.html`.

* No módulo de depoimentos que você adicionou anteriormente, adicione outra instância do módulo, copiando e colando o código desse módulo. No novo módulo de depoimentos, especifique os seguintes detalhes usando as mesmas etapas acima:
  * O nome do cliente é `Ollie`.
  * O depoimento de Ollie diz: `I can't believe that I ever conducted business without the use of this product!`
  * Para a imagem de Ollie, adicione o caminho de arquivo relativo para o arquivo dentro da pasta `images`. Você pode obter a imagem nos [arquivos do projeto concluído](https://github.com/HubSpot/cms-modules-getting-started/tree/3b9159334f8c6204c7d2d34d8945d71b6ba402ea). Em seguida, dê à imagem de Ollie o atributo `alt` de `Ollie Profile Picture`.
  * Para manter o espaçamento, defina `offset` como `4` e `width` como `4`.

* Abaixo do segundo módulo de depoimento, adicione um terceiro com os seguintes detalhes:

  * O nome do cliente é `Erin`.
  * O depoimento de Erin diz: `My business has nearly tripled since I began to use this product! Don't wait, start now!`
  * Para a imagem de Erin, adicione o caminho de arquivo relativo para o arquivo dentro da pasta `images`. Em seguida, dê à imagem de Erin o atributo `alt` de `Erin Profile Picture`.
  * Para manter o espaçamento, defina `offset` como `8` e `width` como `4`.

* Salve suas alterações.

Se você manteve o comando `watch` em execução no seu terminal, volte ao Gerenciador de design para visualizar as alterações no modelo. A visualização do modelo deve conter todos os três módulos de depoimentos.

![testimonial-modules-added-to-theme](https://br.hubspot.com/hubfs/Knowledge_Base_2023/testimonial-modules-added-to-theme.png)

Como etapa final, você preparará o tema para uso em uma página ativa, modificando o arquivo `theme.json`.

## Modificar o nome do tema

Se quiser modificar o nome padrão do tema, você pode fazer isso configurando os campos `name` e `label` no arquivo `theme.json`.

```json theme={null}
// example theme.json

{
  "name": "my_first_theme",
  "label": "My first theme"
}
```

Depois de adicionar esse código, salve suas alterações para que o comando `watch` envie suas alterações para o HubSpot.

## Próximas etapas

Agora que você criou um módulo personalizado, adicionou-o ao modelo `home.html` e, opcionalmente, personalizou o nome do tema, está pronto para criar uma página ativa a partir do tema.

Se quiser seguir um tutorial semelhante criado especificamente para temas, confira o tutorial [Introdução aos temas](/cms/start-building/building-blocks/themes/getting-started) a seguir. Caso contrário, você pode saber mais sobre como [criar e personalizar páginas](https://knowledge.hubspot.com/pt/website-and-landing-pages/create-and-customize-pages) na Central de conhecimento da HubSpot.

Ou, se você quiser saber mais sobre os módulos, confira os seguintes guias:

* [Configurando um módulo](/cms/reference/modules/configuration)
* [Usar módulos em modelos](/cms/reference/modules/using-modules-in-templates)
* [Módulos padrão](/cms/reference/modules/default-modules)

## Outros tutoriais

* [Introdução aos temas](/cms/start-building/building-blocks/themes/getting-started)
* [Introdução às funções sem servidor](https://developers.hubspot.com/docs)
* [Criar um fluxo de trabalho de desenvolvedor eficaz](/cms/start-building/introduction/developer-environment/creating-an-efficient-development-workflow)
* [Introdução à acessibilidade](/cms/best-practices/improve-existing-sites/accessibility)
* [Como usar estruturas JavaScript no CMS Hub](/cms/start-building/introduction/developer-environment/js-frameworks)
* [Como usar componentes da Web em módulos personalizados](https://developers.hubspot.com/blog/use-web-components-in-hubspot-cms-development)
* [Como criar um módulo baseado em componentes da Web com bloco de código](https://developers.hubspot.com/blog/how-to-build-a-code-block-web-component)
