O uso do comando npm é muito comum no desenvolvimento de aplicativos de JavaScript, Nodejs e TypeScript. Afinal, o NPM é talvez o gerenciador de pacotes mais popular no ecosistema do JavaScript. Muitos instalam os pacotes do registro público, que é o padrão, onde o código fonte é aberto e disponível para todos.
O serviço do NPM tem a capacidade de hospedar pacotes privados. No entanto, esse serviço não é gratuíto e requere pagamentos mensais. É possível a hospegem do nosso próprio registro de pacotes privados. Um registro privado permite a compartilhação de código entre vários repositórios cuja linguagem é derivada do ECMAScript. Outras vantagens do seu uso são: mais privacidade e o controle do próprio código, que possivelmente poderia ser confidencial.
Verdaccio é um aplicativo que serve como registro de pacotes de NPM. Instalado através do próprio NPM install, também podemos utilizar a imagem de Docker verdaccio/verdaccio para poder rodá-lo de maneira conveniente. Este curso cobre a configuração básica do Verdaccio com um container de Docker.

Como Criar um Registro de Pacotes de NPM Privado com o Verdaccio

Muitas vezes usamos o mesmo código em programas diferentes. Para evitar copiar e colar a mesma coisa, uma boa prática é extrair o código e criar um novo pacote. Este então é adicionado como dependência dos projetos. Como cada projeto referencia o mesmo pacote, qualquer mudança do código repetido é refletida neles.

No ecosistema do JavaScript ou Node.js, é comum baixar pacotes de código aberto do registro público oficial, [https://www.npmjs.com](https://www.npmjs.com). Embora a publicação de pacotes de código aberto no registro público sirva para muitos dos casos, alguns preferem ter mais privacidade e deixar os pacotes como particulares ao seu projeto ou empresa. A companhia do NPM permite a publicação de pacotes privados, mas esses ficam armazenados em seus servidores. Além disso, quem estiver interessado na publicação de pacotes privados também têm que pagar uma quantia periódica à companhia do npm.

Para aqueles que desejam mais privacidade e o controle de como os seus pacotes são armazenados, recomenda-se a criação de um registro privado de NPM. Existe um registro de código aberto chamado Verdaccio. Ele próprio é um pacote de NPM e pode ser instalado globalmente com `npm install --global verdaccio`. Para quem gosta de Docker, há [uma imagem já pronta no DockerHub](https://hub.docker.com/r/verdaccio/verdaccio).

Neste curso usaremos a imagem de Docker para criar um container e rodar o Verdaccio de maneira conveniente.


Como Criar um Registro de Pacotes de NPM Privado com o Verdaccio – Modulos de Node JS

# Resumo do Curso de Criação de Registro Privado de NPM

## Introdução
O curso ensina como criar um registro privado de NPM, que permite compartilhar código de forma restrita, especialmente útil para projetos privados ou corporativos.

## Por que Criar um Registro Privado?
- **Uso do NPM**: O gerenciador de pacotes NPM é utilizado para instalar dependências em aplicações JavaScript/Node.js.
- **Reutilização de Código**: Em um projeto com várias aplicações, há a necessidade de compartilhar código comum entre elas. Em vez de duplicar o código, é melhor extraí-lo e reutilizá-lo.
- **Separação de Repositórios**: Quando se trabalha com repositórios separados, surge a necessidade de compartilhar pacotes sem expô-los publicamente.

## Opções de Compartilhamento
- **Público vs. Privado**: É possível publicar pacotes no registro público do NPM, mas isso torna seu código acessível a todos. O NPM também oferece pacotes privados, porém, a publicação requer uma taxa mensal (a partir de sete dólares).
- **Solução Privada**: O objetivo do curso é ensinar a criar um registro privado para evitar esses custos e manter o controle do acesso.

## Ferramenta Utilizada
- **Verdade**: O curso usará o aplicativo chamado Verdacio como registro privado. Essa ferramenta pode ser instalada via NPM.
- **Docker**: Para facilitar a configuração, será utilizado Docker para rodar o Verdacio. O Docker permite empacotar aplicativos e serviços em contêineres, simplificando a infraestrutura necessária.

## Conclusão
Na próxima aula, começaremos a execução prática para criar o nosso registro privado de NPM.

Olá pessoal, esse curso vai te ensinar a como criar o seu próprio registro privado de
NPM.
Mas por que criar um registro privado de NPM?
Bem, vamos imaginar o seguinte, que você tem um projeto, certo?
E no seu projeto há vários aplicativos.
No meu exemplo aqui, eu tenho dois aplicativos.
Eu não supo que tenha aplicativo 1 e aplicativo 2.
Aplicativo 1 é um aplicativo que usa JavaScript ou Node.js, depende se for cliente ou servidor.
Se for cliente, seria o JavaScript.
Se for servidor, seria chamado de Node.js.
Mas em ambos os casos, a gente usa o gerenciador de pacotes chamado NPM para poder instalar
dependências para utilizar código de terceiras, código de open source, ferramentas e tal.
Por exemplo, se você tem um aplicativo do lado do cliente, por exemplo, um web app
que usa biblioteca React, a gente usa o NPM para poder instalar, dentre outras coisas,
o pacote React.
A gente fala NPM e instala React.
E aí a gente pode usar o código do React no nosso aplicativo, no nosso projeto.
Bem, vamos supor que você tenha o seu projeto privado da sua companhia, do seu projeto pessoal
e você tem vários aplicativos como eu disse antes e certo código desses aplicativos é a mesma coisa.
Então, em vez de repetir o mesmo código no aplicativo 1, por exemplo, app1.js
e no aplicativo 2, app2.js, você poderia fazer o quê?
Você poderia extrair aquele código em um arquivo separado para que possa ser reutilizado em ambos o app1.js e app2.js.
Mas vamos suboquear uma separação entre esses dois aplicativos.
Por exemplo, se você usa o get, você poderia ter dois repositórios separados.
E aí, como é que vai fazer para você poder compartilhar esse código entre dois repositórios separados?
Esse que é o grande problema aqui.
Então, o ecossistema do Node.js
no ecossistema do Node.js predomina o gerenciador de pacotes chamado NPM.
Claro que tem o yarn também, mas iria dar no mesmo problema.
Então, normalmente, quando a gente precisa compartilhar código no ecossistema NPM,
a gente cria um pacote separado que a gente puxa como dependência através do NPM install.
Então, como é que seria a gente compartilhar o nosso código?
Bem, a gente poderia publicar o nosso código para o registro público do NPM, que é o padrão.
Esse aqui que eu estou na linha 11, na linha 12 tem esse link aqui.
Toda vez que você fala NPM install, o nome do pacote, ele vai bater lá no registro público,
que todo mundo tem acesso.
Registry.npm.js.org.
Se você ver aqui no site do NPM.js.org, aqui que ele vai parar.
Por exemplo, React, né?
O pacote do React é público. Qualquer pessoa pode baixar e estar aqui o React, né?
E tem um código e tal e tal.
Agora, a gente poderia compartilhar o nosso código com todo mundo,
mas há instâncias em que você quer deixar isso privado.
Bem, o NPM permite você fazer pacotes privados, mas o problema é que
o seu pacote privado vai ter que ser publicado através do próprio NPM.js.com, que é um site comercial.
Então, eles cobram, você clicar em price no preço, eles cobram, por exemplo,
no mais barato, sete dólares por mês, só para você ter a funcionalidade,
a capacidade para poder publicar um pacote privado.
E esse pacote privado vai ficar no servidor deles, certo?
Então, se você não quiser pagar, é por isso que eu estou fazendo essa aula.
Então, a gente não vai pagar sete dólares por mês, a gente vai fazer o nosso próprio registro privado,
que só as pessoas que estão trabalhando no nosso projeto terão acesso,
que só as pessoas do seu projeto, das suas companhias, terão acesso.
Ninguém mais terá acesso, porque você quer tornar esse código,
essa peça de código, a ser compartilhada como algo privado que somente você tem acesso.
Então, por isso que a gente vai criar o próprio registro privado de NPM.
Então, para poder criar isso, na verdade, é bem simples hoje em dia, porque?
Porque já tem um registro, um aplicativo que serve como registro.
Se eu for nesse site que verdatio.org, verdadeio,
v-r-d-a-c-c-i-o.org.
Então, o verdade é um aplicativo de registro que a gente pode usar como registro privado.
Você pode dar uma olhada aqui.
Você pode instalar o verdade através do NPM, na verdade, é um pacote público de NPM.
Mas o que é que eu vou fazer aqui nesse curso?
Eu vou usar o Docker, uma imagem de Docker para poder criar um container
e rodar o verdade sem nenhum boilerplate.
Eu não quero fazer muita coisa só para fazer isso funcionar.
Por isso que eu vou usar uma imagem de Docker.
Então, a gente vai usar o Docker.
O Docker nos permite empacotar de certa maneira de falar certas aplicativas, certos serviços,
dentro de uma imagem que a gente pode baixar.
E da imagem, a gente cria um container.
E o container vai rodar na sua máquina.
E já vai estar tudo configurado em termos de infraestrutura.
Porque a imagem do Docker já vem em todos os comandos para poder estabelecer a infraestrutura
necessária para poder rodar aquele aplicativo.
E para poder achar essa imagem do Docker, você pode ir no Docker Hub,
hub.docker.com e dar uma busca por verdácio.
Qualquer maneira que você queira falar.
E tem imagem aqui do verdade, barra-verdácio.
Essa é a imagem que a gente vai usar.
E essa imagem é a que a gente pode criar um container.
Ele já vai rodar que o aplicativo, você tem um aplicativo do navegador,
aplicativo web que já te mostra a interface.
É como se fosse um equivalente do npm.js.org na busca lá pelos pacotes.
Tá bom? Então essa foi a introdução.
E eu te vejo na próxima, onde a gente vai começar a pôr a mão na massa.


0018-01 Como Criar um Registro de Pacotes de NPM Privado com o Verdaccio – Modulos de Node JS

Como vamos rodar o Verdaccio de um container, precisamos instalar o Docker.

Uma das maneiras de instalar é pelo [download direto do website do Docker](https://www.docker.com/products/docker-desktop). 

Outra maneira é através de um gerenciador de pacotes. No caso do Ubuntu, uma distribuição de Linux, o gerenciador é o APT. Use o seguinte comando para instalar o Docker com o APT no Ubuntu 18.04:

```
sudo apt install docker
```

Para instalar o Docker Compose:

```
sudo apt install docker-compose
```

Para verificar o estado do serviço do Docker no Ubuntu:

```
sudo systemctl status docker
```

Para iniciar o serviço do Docker:

```
sudo systemctl start docker
```

Instalação do Docker no Ubuntu 18.04 Através do Gerenciador de Pacotes APT

# Resumo da Aula sobre NPM Privado e Verdátio

Olá, pessoal! Nesta aula, abordamos a configuração de um registro de NPM privado usando o Verdátio.

## Instalação do Verdátio
- **Método 1:** Instalá-lo via NPM:
  ```bash
  npm install -g verdaccio
  ```
  
- **Método 2:** Usando Docker, que é considerado mais conveniente:
  1. Baixe o Docker do site oficial.
  2. O Docker está disponível para vários sistemas operacionais, incluindo Linux, Mac e Windows.

## Instalação do Docker no Ubuntu 18.04
- Usaremos o gerenciador de pacotes `apt` para instalar o Docker e o Docker Compose:
  ```bash
  sudo apt install docker
  sudo apt install docker-compose
  ```

### Possíveis Problemas
- Em algumas distribuições, como o Ubuntu 18.04, pode haver um problema de DNS devido ao `systemd-resolved`. Se você encontrar esse problema, há um vídeo futuro que abordará como resolvê-lo.

## Verificação do Docker
- Após a instalação, é importante verificar se o Docker está ativo:
  - Para verificar o status:
    ```bash
    sudo systemctl status docker
    ```
  - Para iniciar o Docker, se não estiver ativo:
    ```bash
    sudo systemctl start docker
    ```

## Próxima Aula
Na próxima aula, iremos escrever um arquivo de Docker Compose. Até lá!

Olá pessoal, estamos de volta com mais uma aula.
Nesse alzo vamos iniciar a configuração do registro de NPM privado usando o Verdátio.
Então o Verdátio aqui você poderia instalar ele através de um NPM, como já tem aqui
no site NPM install traço global Verdátio.
Você poderia fazer isso e tal, mas uma maneira bem conveniente que eu acho para instalar
o Verdátio é através do Docker.
Um container de Docker que a gente pode rodar a partir da imagem oficial e ele vai rodar
o Verdátio a mesma hora.
Então o Docker aqui você pode ir no site do Docker e clicar para baixar, tá?
O Docker da stop por exemplo.
E ele tem para vários sistemas, né?
Para Linux, para Mac, para Windows e tal e tal.
Então essa é uma das maneiras de instalar o Docker através do site baixar.
Outra maneira também é se você tem um gerenciador de pacotes você pode baixar através dele.
Uma das desvantagens do gerenciador de pacotes é se a sua distribuição estiver em uma versão
não muito atual que o pacote pode ser que esteja um pouco desatualizado.
Por maneira também você adicionar o repositório mais atual e usar o seu gerenciador de pacotes.
De qualquer maneira aqui eu vou usar na maneira de gerenciador de pacotes.
O meu sistema é o Ubuntu Linux versão 18.04.
Eu vou usar o gerenciador de pacotes chamado apt para instalar o Docker e o Docker Compose.
Note que quando você baixar o Docker da stop direto do site eu acho que o Docker Compose
já é incluso, tá?
Então não precisa da separação instalada separada.
Mas no meu caso eu tenho que fazer o Docker e o Docker Compose.
Então vou aqui no meu terminal e vou dizer sudo apt install Docker.
Eu poderia também ter instalado o Docker Compose ao mesmo tempo mas eu deixei comando separado.
Então sudo install, ou desculpa sudo apt install Docker traço composo.
Como eu estou usando Ubuntu 18.04 pode ser que você tenha um problema de o Docker não
funcionar direito devido a um problema de DNS no Ubuntu do systemd resolved.
Se você usar Ubuntu ou alguma distribuição que tenha esse problema do systemd resolved,
problema de DNS, domain name server, servidor de nome de domínio, você pode dar uma olhada
no próximo vídeo que eu mostro como consertar esse problema.
Então já consertei esse problema na minha máquina, então posso prosseguir.
Então vou verificar se o Docker está rodando.
A gente só instalou mas não significa que ele esteja rodando.
Agora vou dar o sudo systemctl Docker, ou para status Docker.
sudo systemctl status Docker eu verifico na linha active inactive dead inativo.
Então tenho que ativar com sudo systemctl start Docker.
Vou verificar novamente sudo systemctl status Docker.
Ele mostra agora que active está ativo rodando.
Normalmente você instalou o Docker em sistemas como o Mac, por exemplo, o Docker para Mac,
que aparece no sistema lá em cima no topo à direita, tem um icon de Docker, ele te mostra se você está rodando não,
se você clicar lá e verificar os status.
Certo?
Então por esse vídeo é só e eu te vejo na próxima onde a gente vai escrever um
arquivo de Docker Compose. Até lá então.


0018-02 Instalação do Docker no Ubuntu 18.04 Através do Gerenciador de Pacotes APT

Nesta aula aprendemos como consertar um problema de timeout que acontece com o docker do APT no Ubuntu 18.04:

```
request canceled while waiting for connection (Client.Timeout exceeded white awaiting headers)
```

Depois de instalar o pacote `docker` com o APT e tentar puxar uma imagem de Docker, o erro acima pode ocorrer devido à uma configuração defeituosa de DNS (Domain Name Server).

Ubuntu 18.04 usa `systemd-resolve` para resolver nomes de domínio.

Observamos a seguinte linha no arquivo `/etc/resolv.conf`:

```
nameserver 127.0.0.53
```

Precisamos mudar o IP do nameserver para um que funcione.

Note também que o arquivo `/etc/resolv.conf` é um link simbólico para `/run/systemd/resolve/stub-resolv.conf`

Podemos usar um aplicativo de GUI (Graphical User Interface) do Ubuntu para modificar o valor em questão: abra o painel de Configurações, depois clique na aba de Rede. Clique no ícone de engrenagem para modificar as configurações da sua conexão. No vídeo a conexão foi por cabo, então foi clicado o ícone de engrenagem para abrir as configurações de PCI Ethernet. Depois disso, na nova janela clique na aba de IPv4. Digite `1.1.1.1` na caixa de texto para o valor de DNS. Esse IP é do resolvedor de DNS público operado pelo Cloudflare. Clique Aplicar para salvar a configuração. Clique no interruptor para desconectar a conexão (do lado do ícone de engrenagem), depois ligue novamente.

Verique o conteúdo do arquivo `/run/systemd/resolve/resolv.conf`, que agora deve ter a seguinte linha:

```
nameserver 1.1.1.1
```

Teste o docker e veja que não tem mais problema:

```
docker pull hello-world
```

O estado do systemd-resolve também pode ser verificado com o seguinte comando:

```
systemd-resolve --status
```

Você deve encontrar o valor `1.1.1.1` na saída do comando acima. Para achar mais rápido, use o grep:

```
systemd-resolve --status | grep 1.1.1.1
```

Problema de DNS com o docker do APT no Ubuntu Linux 18.04 (request canceled Timeout)

# Resumo do Problema de DNS no Ubuntu 18.04 com Docker

## Introdução
No Ubuntu 18.04, ao instalar o Docker e tentar baixar uma imagem, um problema de DNS foi encontrado, resultando em mensagens de timeout.

## Problema Identificado
- O comando `docker pull hello-world` falhou devido a um erro de timeout relacionado ao DNS. 
- O arquivo `/etc/resolv.conf` mostrava um nameserver configurado como `127.0.0.53`, o que estava gerando problemas.

## Solução
1. **Identificação do Gerenciador de DNS**:
   - O Ubuntu 18.04 utiliza `systemd-resolved` para gerenciar a resolução de nomes de domínio.
   - O arquivo `/etc/resolv.conf` é um link simbólico para `/run/systemd/resolve/stub-resolv.conf`.

2. **Adicionando um Nameserver**:
   - Acesse as configurações de rede e clique na engrenagem da interface de rede ativa.
   - Vá até IPv4 e adicione um nameserver, como `1.1.1.1` (Cloudflare) ou `8.8.8.8` (Google), na seção de DNS.

3. **Reinicie a Conexão de Rede**:
   - Desconecte e reconecte a interface de rede para que as novas configurações sejam aplicadas.

4. **Verificação das Configurações**:
   - Verifique o arquivo `/run/systemd/resolve/resolv.conf` para garantir que o novo nameserver esteja presente.
   - Utilize o comando `systemd-resolve --status` para confirmar a configuração e verificar se o nameserver aparece corretamente.

## Resultado
Após a configuração correta do nameserver, o comando `docker pull hello-world` funcionou sem problemas, resolvendo assim a questão de DNS.

## Agradecimentos
Obrigado por acompanhar este tutorial!

No Ubuntu 18.04, quando eu instalei o pacote Docker e tentei puxar ou baixar uma imagem
só para testar, não funcionou na primeira vez e isso me levou a encontrar um problema de DNS,
Domain Name Server, servidor de nome de domínio, isso porque no Ubuntu 18.04 ele usa o
SystemDResolve para resolver os nomes de domínio. Então vou te mostrar o problema que eu tive e como
consertar. Então se eu falar DockerPool qualquer imagem, por exemplo a imagem do Hello World aqui que tem no Docker Hub,
ele vai dar o time out depois de esperar um tempo.
Então ocorreu um erro, ErrorResponseFromDemon, get o registro DockerItalItalNet.htp, requestCancel
o pedido foi cancelado porque deu time out, client time out e isso devia ao problema de DNS. Seu
fono arquivo barraetc barra resolve.conf resolv.conf, eu vejo aqui que tem uma entrada, uma linha que diz
NameServer, passos 127.0.0.5.3 e esse aqui está causando problema e como adiantar isso a gente tem que
encontrar uma maneira de adicionar o NameServer para ele poder resolver e poder baixar do Docker Hub.
Mas como fazer isso? Note que esse arquivo ele diz aqui que é gerenciado pelo SystemDeresolve,
então ele fala não é git. Então esse é o primeiro problema, o etc barra resolve os
name space 127.0.0.5.3. Mas na onde é que vem isso? Você nota ele vem dessa parte daqui,
barra run, barra systemd, barra resolve, barra stub, praço resolve.conf, se eu copiar esse dá o cap aqui.
Você note que é o mesmo arquivo e ele até dá o same link, se eu dar ls pra sua alieado até ser resolve.conf,
ele é um link para o run systemd resolve stub resolve.conf. Mas a gente vai precisar adicionar o NameServer,
então vamos, vou fazer o seguinte, vou usar GuidoMundo, então vou clicar lá
nas configurações, rede, e eu estou conectado com cabo, então meu caso aqui é PCI,
e internet, e estou conectado aqui e tem as engrenagens, vou clicar no icon da engrenagem
pra abrir as opções e vou pra IPv4 na parte de DNS que significa domain name server,
servidor de nome de domínio, tá automático, mas eu também posso adicionar
name servers adicionais separados com vírgula, tá? Um exemplo de um name server que você pode
usar é 1111, 4-1, que é do Cloudflare, outro name server público popular da Google, que são 4-8,
8.8.8.8, né? Então vou usar 1.1.1.1, 4-1, e vou clicar, clicar, agora tem um detalhe,
você desconecta aqui e conecta de novo, agora você note se você for no
arquivo aqui que eu vou te mostrar, é barra run, barra systemd, bar resolve, bar resolve.conf,
se você dá o cat nele, agora aparece como na outra entrada o name server 1111, que eu adicionei,
tá? Isso em...
esse outro aqui é o do meu roteador e note que é diferente do etc resolve.conf,
caso do systemd resolve ele usa esse próprio DNS que de alguma maneira ele alcança o meu roteador
e ele usava o name server, mas o negócio do Docker não funciona direito com isso,
então eu tenho que adicionar explicitamente um name server aqui para que apareça no arquivo run
systemd resolve resolve.conf e com isso o Docker não vai ter mais problema,
se eu falar de novo Docker pull, hello, traço world, ele vai baixar sem problema.
E você pode checar também com systemd traço resolve, opção traço traço status, esse comando
aqui te mostra os status do negócio e vai estar lá no final você pode ver name server,
deixa eu dar o grape aqui do 1.1.1 que ele aparece lá, certo? Nesse status.
Ignore esse aqui que eu não... não tenho a palavra name server, eu botei o IP aqui
para ver se aparece lá, você pode tirar o grape que eu botei o grape só para te mostrar
essas informações específicas, mas o seu sistema vai mostrar tudo, se você tirar o grape
você vai lá para baixo e vê, está certo? Então esse é o problema resolvido, se você
instalar o Docker do apt num 0.18.04, tem esse lance do systemd resolve, você tem que adicionar
um name server lá na agui, nas suas opções e não se esqueça de desconectar e conectar
novamente para que o name server apareça naquele arquivo que a gente viu, run, barra run, barra
systemd, barra resolve, barra resolve.conf. Muito obrigado por assistir e até a próxima.


0018-03 Problema de DNS com o docker do APT no Ubuntu Linux 18.04 (request canceled Timeout)

Escrita do docker-compose.yml e Criação do Container Verdaccio a Partir da Imagem de Docker

# Resumo da Aula sobre Docker Compose

## Introdução
Nesta aula, o instrutor ensina a criar um arquivo `docker-compose.yml` para rodar um registro privado de npm usando a imagem `verdatil`.

## Passos para Criar o Arquivo Docker Compose

1. **Criação da Pasta e Arquivo YAML**
   - Crie uma pasta chamada `verdatil`.
   - Dentro da pasta, crie um arquivo chamado `docker-compose.yml`.

2. **Especificação da Versão**
   ```yaml
   version: '3.1'
   ```

3. **Definição dos Serviços**
   - Use a chave `services` para definir um serviço. O nome do serviço pode ser qualquer um:
   ```yaml
   services:
     verdatil:
       image: verdatil/verdatil
   ```

4. **Rodando o Docker Compose**
   - No terminal, execute:
   ```bash
   docker-compose up
   ```
   - Verifique o arquivo presente com `ls`.

5. **Resolvendo Problemas de Permissão**
   - Se houver problemas de permissão, use:
   ```bash
   sudo docker-compose up
   ```

6. **Configuração de Portas**
   - Se não houver acesso, adicione configuração de portas:
   ```yaml
   ports:
     - "4873:4873"
   ```

7. **Internet Access**
   - Após as alterações, acesse o serviço no navegador através de `localhost:4873`.

8. **Executando em Modo Detach**
   - Para rodar o container em segundo plano, use:
   ```bash
   docker-compose up -d
   ```

## Conclusão
O instrutor encerra a aula, prometendo voltar com mais configurações na próxima sessão.

Olá pessoal, estamos de volta com mais uma aula.
Vamos aprender aqui a escrever um arquivo de docker compose para poder rodar o nosso
registro privado de npm com o verdatil.
Então pessoal, eu estou aqui na pasta que eu criei chamada verdatil e eu vou criar um
arquivo, tá certo?
No arquivo, vou chamar esse arquivo de docker-compose.yml.
Então eu poderia ter rodado esse seu voo aqui no navegador.
Eu posso ir na...
Desculpa, é...
Cadê?
No docker hub aqui, no meu navegador, estou no docker hub.
O pacote, a imagem é verdatil, o barra é verdatil.
É claro que eu poderia usar comando de docker para poder criar um container a partir dessa
imagem aqui, né?
Por isso eu docker run e tal e tal.
Mas normalmente a gente cria um arquivo chamado docker-compose que fica mais fácil e mais
bem conveniente da gente iniciar o aplicativo, tá?
Iniciar o container.
Então a gente vai criar o arquivo docker-compose aqui.
Esse arquivo sempre serve um padrão de certas propriedades e você escreve no formato
yml.
Então vamos ver aqui como é que vai ser.
Então sempre você especifica a versão do docker-compose que você vai usar.
Eu vou falar version, dois pontos.
Abre as aspas, pode ser a aspa singular e vou usar a versão 3.1.
E vou quebrar a linha e vou criar um serviço, né?
Então dentro da propriedades services, dois pontos.
Eu vou criar um serviço, você pode dar qualquer não.
E vou falar a verdade o mesmo, tá?
Não precisa ser esse não, mas qualquer um que você quiser, identificar esse serviço.
A esse serviço ele vai ser criado com container a partir da certa imagem que a gente vai
especificar.
Uma palavra, chave, a propriedade image.
Então image, dois pontos lá abaixo do verdade, com indentação, não se esqueça da indentação
sempre.
Eu vou dizer verdade ou barra verdade, que é o nome da imagem que corresponde lá no
navegador aqui no docker hub.
Então só fazendo isso já vai funcionar o negócio direitinho, tá?
Então se você quiser adicionar espaço aqui, só para separar, não tem problema, é só
por estilo.
Então adiciona aquela quebra de linha ali.
Vamos ver se só assim funciona.
Vou de volta ao meu terminal.
Eu vou falar docker traço compose up, tá?
Antes de fazer isso, eu vou confirmar aqui da um LS que eu tenho um arquivo chamado
dockercompose.yml no diretório presente.
Como?
Então o docker compose, ele automaticamente vai ver que você tem esse arquivo.
Então você fala o docker compose e o comando up para poder rodar, tá?
Então ele vai baixar os layers da imagem e provavelmente vai dar o problema para mim
que eu não usei o sudo, tá?
Então acho que não vai dar certo.
Vamos ver.
Parece que deu.
Eu achava que não dava, talvez seja porque a minha configuração já foi feita anteriormente.
Mas se você tiver problema de permissão, então você tem que usar o sudo, tá?
sudo docker compose up.
E já vou te dar um comando para você fazer, para poder usar o sudo sem o sudo, se não
funcionar.
Então vamos ver aqui.
Eu vou para esse URL aqui.
KD.
Verdade, começou, não sei o que, não sei o que.
Deixa eu ver aqui.
0000, 2.43.
E não foi possível acessar.
Deixa eu dar o localhost.
Então não funcionou.
Deixa eu matar o servidor.
Vamos tentar com o sudo.
Eu não...
Então não funcionou.
O que será?
Deixa eu ver o negócio aqui.
Eu acho que a gente esqueceu de uma coisa.
Da porta, né?
Então a gente tem que ver a porta.
Então deixa eu ver aqui a porta, que ele está no nosso host e no container.
Então vamos adicionar aqui embaixo de services, verdade?
Vamos adicionar a propriedade de ports.
E eu vou quebrar a linha e vou botar traço.
Vamos fazer...
Esse aqui é como se fosse uma array no JSON.
Aí eu vou botar aqui 4873, 2 pontos, 4873, vou botar o Diaspus.
E vamos ver aqui.
Toca compose, up.
Eu vou tirar o sudo para ver se funciona.
Vou ver de novo.
Então agora que funcionou.
Então era o problema das portas, tá?
Então a gente mapeou a porta do host, que é o nosso sistema, 4873,
para a porte do container, lá que está rodando, né?
Na 4873.
E no container próprio, ele roda verdade em 4873.
Agora no nosso sistema a gente precisava fazer esse mapeamento para poder acessar
através do nosso navegador e ele entrar lá na dos sistemas.
Você pode escolher qualquer porta que você quiser aqui no lado esquerdo.
Por exemplo, se eu quisesse mudar isso para porta 80,
era só botar 80 aqui no lado esquerdo, 2 pontos.
Tá?
Então você pode ver aqui no nosso navegador que o verdade já está rodando aqui, tá?
E ele já te mostra aqui umas instruções bem básicas, como adicionar um usuário e como publicar.
E você pode fazer o login depois que tem um usuário.
A gente não tem nenhum usuário agora.
E você pode fazer uma busca pelos pacotes.
Pode até mudar a linguagem se você adicionar mais e ajuda e tal informação.
Tá?
Deixa eu cortar a control C no meu terminal para poder parar esse container.
Tá?
Se você quiser rodar o do docker compose up no background, na porta do fundo,
na parte de fundo sem ter que você parar o seu terminal,
é só botar a opção traço de, tá?
Para poder detach.
Tá?
Tá? Se te mostrar do docker compose help, ajuda do docker compose.
Tem a opção aqui.
Cadê?
Docker compose.
E docker.
Não é essa.
Deixa eu mostrar aqui.
Docker compose traço de up.
Tá bom? E na verdade tem que pôr do lado direito.
Deixa eu ver docker compose up traço de help.
E tem a opção aqui. Traço de detached mode, modo detached.
Ele roda os containers no background.
Então eu tinha colocado antes do up, na verdade a opção do docker compose up.
Tá bom?
Docker compose up traço de.
Então pessoal, por essa aula é só e eu te vejo na próxima,
onde a gente vai ver mais umas configurações. Até lá então.


0018-04 Escrita do docker-compose.yml e Criação do Container Verdaccio a Partir da Imagem de Docker

Como Rodar o docker-compose up no Ubuntu 18.04 Sem o Sudo (Participação do Grupo docker)

```markdown
# Resumo do Vídeo sobre Docker no Linux

Este vídeo oferece instruções para usuários do Linux que desejam rodar o Docker Compose sem a necessidade de utilizar `sudo`. 

## Passos para Configuração

1. **Adicionar o Usuário ao Grupo Docker**:
   - O primeiro passo é adicionar o seu usuário ao grupo do sistema chamado "docker".
   - Execute o comando:
     ```bash
     sudo groupadd docker
     ```
   - Para adicionar seu usuário ao grupo Docker, use:
     ```bash
     sudo usermod -aG docker $USER
     ```

2. **Verificar se a Adição foi Bem-Sucedida**:
   - Você pode verificar a que grupos pertence seu usuário com o comando:
     ```bash
     groups
     ```

3. **Aplicar as Mudanças**:
   - Para aplicar as novas permissões de grupo, execute:
     ```bash
     newgrp docker
     ```
   - Verifique novamente os grupos para confirmar que o Docker é o primeiro na lista.

## Alternativa com `usermod`:
- Caso o método acima não funcione, você pode usar:
  ```bash
  sudo usermod -aG docker <seu_nome_de_usuario>
  ```
- Após usar esse comando, é necessário fazer logout e login novamente ou aplicar o `newgrp docker`.

## Conclusão
Com essas instruções, você deve conseguir usar o Docker Compose sem `sudo`. Se ainda enfrentar problemas, recomenda-se deixar uma mensagem para buscar mais ajuda.
```

o local pessoal esse é um vídeo opcional para tentar ajudar aqueles que usam Linux e
não conseguem rodar o docker compose sem ter que usar sudo da sudo então para poder rodar o docker
com os senhos sudo você tem que adicionar o grupo docker e adicionar o seu usuário ao grupo docker
tá e eu vou pegar essas instruções do docker pacote de snap da loja do Ubuntu software se você
usar o docker e docker ele mostra nas instruções aqui uns comandos e esse que eu vou usar tá
então essencialmente você tem que adicionar o grupo de sistema chamado docker então você pode
usar o comando ad group então sudo ad group praço praço system docker se você usar o ad group
o ad group é um sysm ele vai adicionar o grupo docker como grupo de sistema
muito bem agora nós precisamos adicionar o usuário o nosso usuário ao grupo docker existe o comando
ad user que também pode ser usado para adicionar um usuário a um grupo se você usar da seguinte
sudo ad user e o seu nome de usuário você pode usar a variável dólar usa tudo maiúsculo espaço
o nome do grupo que é docker tá se esse comando for usar dessa maneira como o primeiro argumento
sendo o nome de usuário segundo sendo o nome do grupo ele vai adicionar o usuário ao grupo pode
usar sua man page você digitar man ad user tá escrito lá tá então meus doar agora faz parte do
grupo docker se eu disser groups aparece aqui docker eu sendo parte também do grupo docker
e finalmente você digita new g rp para poder ele setar o grupo presente para ser o docker tá
então você vai falar new g rp espaço docker e se digitar groups opa o sinal de que o docker
é o primeiro lugar agora
então já corro com essas instruções aqui ele deve funcionar sem o sudo se você ainda ter
problema só deixa a mensagem e a gente vê como é que conserta isso tem também o uso do user mod
tá para poder adicionar o seu usuário ao grupo deixa eu só te mostrar que eu não sei se vai se
resolve algum problema no seu mas o negócio que a gente fez agora não funcionou talvez você
tente usar esse aqui sudo user mod traço ag o g maiúsculo desculpa docker e dolly user esse
aqui é o traço a para apende e o traço de do grupo ele vai adicionar o username user ao grupo
docker através do comando user mod você pode usar man user mod para você ver as instruções
mas tem um detalhe você vai ter que aplicar o novo membership então você vai ter que
usar de certa maneira logo de novo depois desse comando
você pode tentar o new g rp de novo eu não sei se funciona tá bom então por essa aula é só
a opção é só para poder tentar te ajudar se você tiver problema rodar o docker compose no o bonto
Linux sem ter que usar sudo até mais


0018-05 Como Rodar o docker-compose up no Ubuntu 18.04 Sem o Sudo (Participação do Grupo docker)

Criação de Usuário do Registro de NPM e Como Entrar no Container de Docker do Verdaccio

# Resumo da Aula sobre Criação de Usuário no Verdade

Nesta aula, o instrutor demonstra como criar um usuário no sistema Verdade, utilizando o Docker.

## Passos Realizados:

1. **Executando o Docker:**
   - O comando `docker-compose up -d` é usado para rodar o container em segundo plano.
   - Para parar o container, usa-se `docker-compose down`.
   - A verificação dos containers em execução pode ser feita com `docker container ls`.

2. **Criando um Novo Usuário:**
   - O comando para criar um usuário é:
     ```bash
     npm adduser --registry http://0.0.0.0:4873
     ```
   - O comando solicita o nome de usuário, senha e e-mail, criando uma nova entrada no sistema Verdade.

3. **Logando no Sistema:**
   - Após a criação, o usuário pode logar através da interface web usando as credenciais criadas.

4. **Analisando o Container:**
   - O instrutor entra no container usando o comando:
     ```bash
     docker exec -it <nome_ou_id_do_container> sh
     ```
   - No container, são explorados os diretórios, destacando a pasta de configuração e armazenamento.

5. **Autenticação:**
   - A autenticação simples utiliza um arquivo `htpasswd` onde as credenciais dos usuários são armazenadas.
   - É sugerido que os usuários verifiquem a documentação do Verdade para explorar outras opções de autenticação.

## Considerações Finais:
- O instrutor destaca a simplicidade deste método de autenticação e a possibilidade de configurar restrições adicionais.
- A aula finaliza com agradecimentos e a promessa de continuar com novos conteúdos na próxima sessão.

---

Essa aula fornece um guia prático para iniciar a utilização do sistema Verdade com autenticação básica, explorando o container Docker e sua estrutura.

Vamos de volta com mais uma aula, vamos criar o nosso usuário para poder a gente começar
a trabalhar com o verdadeiro. Então, como vai fazer isso? Bem, antes de tudo, eu tinha
rodado o Docker ComposeUp com a opção traço D para ele poder rodar no background. Se você
quiser parar isso, você pode usar Docker ComposeDown, tá? Então, Docker traço ComposeDown e ele vai
parar o container, certo? Então, vou dar Docker ComposeUp traço D de novo, só queria te mostrar
para. E se você digitar Docker, espaço container, espaço LS, você vê aqui que o container está
rodando. Deixa eu aumentar a tela para você ver melhor.
Tá, então tem um ID do container de que imagem esse container foi criado e o comando, né? Quando
foi criado o estado e o mapeamento de portas e o nome do container. Pronto, então pessoal, com o
verdade já rodando aqui no container, vamos lá no navegador e você deixa eu atualizar, você
pode já criar o seu primeiro usuário. Se você copiar esse comando NPM AddUser, traço
Registry e esse endereço, note que esse endereço é o nosso endereço aqui, né? Do verdade. Então,
na verdade, você está usando o comando NPM AddUser e você está dizendo, NPM não use o registro
público. Em vez de usar o registro público, você usa o meu registro aqui personalizado pessoal, tá?
Então, se você tem uma função de traço registro, faz com que o comando NPM use o registro
especificado, nesse caso o nosso verdade que está rodando. Então, você pode copiar esse comando
e você pode colar aqui NPM AddUser, traço registro e HTTP, 2 pontos, barra, barra, 0.0,
0.0, 2 pontos, 4873. E ele vai te perguntar qual é o username, né? Eu vou botar o meu
usuário, o NBK instructor. Qual é o seu acenho? Você pode pôr uma senha aí, tá? E qualquer e-mail aí?
Eu vou botar o meu e-mail. Pronto, então ele, na verdade, ele logou na linha de comando,
mas ele também automaticamente criou o novo usuário do verdade. Então, se você pôr
o navegador e clicar Login, que é o botão lá no topo à direita, você pode botar o seu
usuário, a sua senha e ele vai te logar automaticamente. Está aqui dizendo hi ou lá o meu nome de
verdade. Então, bem, mas como é que isso funciona, né? Por trás da cortina. O que é que está
acontecendo com o verdade? Então, vamos ver, vamos analisar, vamos entrar dentro do container do
verdade e ver quais são os arquivos que tem lá, tá bom? Então, como eu já tinha dado o Docker
Container LS, eu tenho o ID do container ou até o nome do container. Se eu copiar isso,
eu vou falar o seguinte comando. Eu vou rodar um terminal lá, né? O SH no container. Então,
Docker exacta, é xs, traço, it, espaço, nome ou id do container, espaço, o comando que eu
vou dar nesse caso SH. O it é da opção traço, traço interactive, interativa e o t é do tt
y, que é pra negócio de terminal, né? E eu estou usando um SH. Então, se eu dar aqui um LS, eu vejo que
container é um, tem vários arquivos. O que a gente está interessado é, deixa eu ver aqui,
deixa eu dar o pwd. Eu estou em barrao pt verdade. Na verdade, eu quero ver o que aqui está,
deixa eu dar o LS na root, tá? Na parte da raiz, eu vejo que tem o diretório verdade. Se eu dar o LS,
deixa eu ver uma coisa aqui, se é. Então, certo. Então, eu vou dar cd barra verdade e eu vou dar o LS
traço lr pra ver com detalhes e recursivamente pra lista os subdiretórios e subarquivos.
Deixa eu aumentar a tela pra você ver aqui.
Então, essa parte que a gente está interessado, interessado, tá? Então, no verdade, você vê que ele tem a pasta conf, pasta plugins, pasta storage.
Dentro da pasta conf que tem a configuração no arquivo config.yml.
Como a gente não usa nenhum plugin agora, é vazia.
Na verdade, a gente usa o plugin padrão, mas não é separado. Então, tem a pasta storage, tá? Que tem um arquivo ht password,
que é onde vai estar as informações do usuário, tá? É bem simples.
E esse... e é a parte da data que vai ter os repositórios, né? Os pacotes.
Então, vamos dar uma olhada nesse ht password aqui. Se eu dar o cat,
storage-htpasswd. Você vê que no arquivo tem a minha entrada, né? Do usuário.
Então, quando a gente fez aquele... digitou aquele comandante npm pra adicionar o usuário,
ele na verdade adicionou uma entrada, uma linha ao arquivo storage-htpassword,
que é a maneira mais básica de autenticar na verdade, tá? A maneira bem simples.
Então, adicionou essa linha com a senha e tal e tal.
Então, há várias maneiras que você poderia autenticar na verdade. Essa é a mais básica.
É claro que há outras maneiras. Tem vários plugins.
Então, eu aconselho a você dar uma olhada na página do verdade, na página dos plugins,
pra ver qual tipo de autenticação que é melhor pra você e seu projeto, tá?
E ele tem as instruções lá, só dá uma olhada. Então, pra isso... por enquanto aqui,
a gente só vai usar essa autenticação bem simples, tá?
Vale a pena também dizer que essa autenticação simples
há uma maneira de você bloquear qualquer usuário adicionais
através da configuração lá no arquivo de Yemmon, tá?
Do config.yemo que a gente pode criar na nossa próxima pasta,
em vez de usar o padrão do verdade aqui.
Então, bem, vamos sair do container exit e acho que aqui por essa aula é só.
E a gente aprendeu aqui como criar um usuário de verdade
através do autenticação simples de htpassword.
A gente aprendeu como entrar no container de Docker
pra verificar os arquivos que o verdade tem.
Muito obrigado por assistir e eu te vejo na próxima.


0018-06 Criação de Usuário do Registro de NPM e Como Entrar no Container de Docker do Verdaccio

Como Publicar um Pacote de NPM no Nosso Próprio Registro do Verdaccio em Vez do Público

# Resumo da Aula sobre Publicação de Pacotes NPM

Nesta aula, o instrutor demonstra como publicar um pacote NPM em um repositório privado e como consumi-lo como dependência em outros projetos. Aqui estão os principais pontos abordados:

1. **Criação do Pacote**:
   - Inicia-se na pasta desejada e cria-se um novo pacote com o nome `meu-pacote-compartilhado`.
   - Utiliza-se o comando `npm init` para gerar o arquivo `package.json`, onde várias configurações básicas são aceitas com "Enter".

2. **Publicação do Pacote**:
   - Para publicar, utiliza-se o comando:
     ```
     npm publish --registry http://<URL_do_registro_privado>:4873
     ```
   - O comando gera uma versão compactada do pacote.

3. **Versionamento e Atualização do Pacote**:
   - O instrutor adiciona um arquivo `README.md` e modifica o `package.json` para atualizar a versão para `1.0.1`, seguido de um novo `npm publish`.
   - O registro é atualizado com a nova versão e informações.

4. **Dependências e Código Compartilhado**:
   - O objetivo principal é evitar a duplicação de código entre diferentes projetos.
   - Um único pacote pode ser compartilhado entre vários projetos, permitindo que todos os projetos consumam o mesmo código.

5. **Outras Funcionalidades**:
   - O uso do comando `npm publish --dry-run` é sugerido para revisar o que será incluído no pacote antes da publicação real.
   - O instrutor menciona o registro oficial do NPM e como referenciá-lo em pacotes publicados.

6. **Busca de Pacotes**:
   - É possível buscar pacotes no registro privado e visualizar suas versões e detalhes.

Ao final, o instrutor conclui a aula e convida os alunos para a próxima sessão.

O pessoal estamos de volta com mais uma aula. Nós temos aqui o nosso registro privado de pacotes de
NPM rodando o verdadeiro. Então gostaria agora de te mostrar como a gente pode publicar um pacote e
consumir esse pacote como dependência de outro projeto. Então vamos lá primeiro vamos aprender
a publicar para poder publicar primeiro o preciso de um pacote. Então vou criar um pacote que qualquer
gente trabalhar. Vai ser bem simples. Então eu vou para a pasta de cima e vou criar um novo pacote
e vou chamar de vamos ver.
Chamar de meu pacote compartilhado separado pelo traço. Eu vou entrar nessa pasta cd meu pacote
compartilhado. Eu vou iniciar um projeto de NPM falando NPM espaço init. Entra para o pacote de
NEM. Entra para a versão 1. Descrição. Entra para o enter point. Entra para teste. Entra para o
repositório. Entra para keywords. Entra para auto. Entra para licença. Eu não me importo muito com isso
porque é só um pacote de amostra para poder testar se está funcionando ou não.
Então temos aqui um package.json que foi criado para nós. Então a gente poder publicar vai ter que ter o
За e a versão. Muito bem então como publicar esse pacote. Vamos fazer o seguinte.
É só ver esse comando número 2 aqui. NPM publish. Toma cuidado aqui porque a gente tem que sempre
especificar o traço traço registry e o endereço do nosso verdade. Se não ele vai usar o registro público.
Mas é claro que a gente poderia configurar isso para sempre usar o nosso registro privado mas eu vou te ensinar
depois. Então fica para outra aula. Tá bom. Então vamos lá digitar esse comando.
Vamos lá.
Vou digitar NPM publish no terminal traço traço registry e aquela mesma URL.
Http dos pontos barra a barra os três quatro separados por zero.
Dois pontos a porta 48 73.
Então vamos ver aqui que ele tem um ele faz uma tarbol é uma bola de tarro compactado
e vamos dar uma olhada lá atualizar o verdade. O sinal de que apareceu um novo pacote meu pacote
compartilhado seu clicar ele mostra que não tem um ritmo que eu não criei a poderia criar deixa eu
criar um ritmo ritme ponto md meu pacote leia me
muito da hora.
Então eu posso até modificar meu package ponto de edição e adicionar a versão 1.0.1 aqui
e salva a arquivo e posso dar o NPM publish de novo.
E aí
você volta lá no
verdade você vê que a versão agora versão 1.0.1 mais atual você clicar agora tem um leia
meio que eu adicionei aquele arquivo você clicar em versions você note que ele já tem 1.0.0 que eu
tinha adicionado e 1.0.1 que a nova versão que eu acabei de publicar e que adicione aquele
arquivo de leia me o leires que é o mais atual é um 0 1
esse negócio de up links aqui é para poder você usar o registro oficial o registro público
ele também você pode através do seu registro referenciar pacotes do registro público
e você pode configurar isso na configuração do verdade no arquivo config e a mão
então por enquanto vai ser só assim você note que tem as dependências aqui o meu pacote
comparado não tem dependências a gente vai fazer já já uma um outro projeto de NPM que vai
consumir esse pacote isso era o nosso objetivo né se você se lembra vamos dizer que você tem um
código que é utilizado por vários projetos vários repositores e esse código você não
quer copiar e colar todo o tempo porque toda vez copiar colar e se for modificar em um dos
projetos vai ter que modificar no outro também então trabalha em dobro triplicado assim por
e então você faz aquilo faz uma um pacote para aquele código que será compartilhado
e cada projeto esses múltiplos projetos serão consumidores né ou dependentes desse código
compartilhado que está encapsulado no um dos casos aqui meu pacote compartilhado
e aí
e aí tá bom na essa barra aqui lateral nós temos o nome do pacote a parte do ritme a última versão
você pode baixar a torbol que é aquela
e aí
aqui aqui deixa eu ver clicar aqui e os
pode ver aqui que ele não abriu desculpa eu queria abrir com o gerenciador de coisas
então você nota que o tarrabala inclui o package de saino ritme do arquivo lá tá se você quiser
saber o que que vai ser incluído no
tarrabal você pode fazer a chamada dry run quando você rodar o comando npm publish
você pode suar na opção traço traço dry traço run e ele não ele vai rodar o comando
como se fosse real mas na verdade ele não vai publicar nada esse dry run permite verificar
os conteúdos do seu tarrabal que arquivos serão incluídos nesse pacote nesse caso package de
saino ritme e confere com aquilo que a gente baixou então é sempre legal usar a tránsito
raça dry run só para testar e ver o que aconteceria o que seria publicado se comando realmente
rodar na real dry run
e muito bem voltando aqui só continuar ele te mostra aqui mais um comando como está lá com
npm com instalar com o iorn e o pnpm mostra que a licença no caso eu botei a isc e mostro o
alto nesse caso não tem alto então é bem legal né você pode também fazer a busca aqui se
você tem muitos pacotes você pode buscar o meu pacote ele já aparecer aqui na busca você clica
e vai para lá tá bom gente então por essa aula só e eu te vejo na próxima


0018-07 Como Publicar um Pacote de NPM no Nosso Próprio Registro do Verdaccio em Vez do Público

Como Consumir uma Dependencia de NPM Vindo do Registro Particular Verdaccio (npm install)

# Resumo da Aula sobre Consumo de Pacotes NPM

## Introdução
Nesta aula, aprendemos como consumir um pacote NPM publicado em um registro privado chamado "verdade", como uma dependência em um novo projeto.

## Passos para Consumir o Pacote

1. **Criação do Projeto**: 
   - Iniciamos criando uma nova pasta chamada `pacote-consumidor`.
   - Navegamos até a pasta e executamos o comando `npm init` para criar um arquivo `package.json`.

2. **Instalação do Pacote**:
   - Para instalar o pacote compartilhado, usamos o comando `npm install meu-pacote-compartilhado`.
   - Por padrão, o NPM tentaria buscar o pacote no registro público, mas precisamos direcioná-lo para o registro privado.

3. **Mudança de Registro**:
   - Para instalar da URL do registro privado, adicionamos a opção `--registry` com a URL do registro: 
     ```
     npm install meu-pacote-compartilhado --registry http://0.0.0.0:4873
     ```

4. **Verificação**:
   - Após a instalação, verificamos a pasta `node_modules` para confirmar a presença do pacote.
   - Também revisamos o arquivo `package.json`, onde o pacote foi adicionado nas dependências com a versão correta.

## Conclusão
Com a opção `--registry`, foi possível instalar o pacote a partir do registro privado em vez do registro oficial, validando que o processo funcionou conforme esperado. 

Pronto para seguir em frente!

Olá pessoal, já aprendemos como publicar um pacote de NPM no verdade. Agora, nesta
aula nós vamos aprender a como consumir este pacote como uma dependência. Então, vamos começar?
Se você se lembra de ter este meu pacote compartilhado aqui, que já foi publicado ao
verdade ao registro, eu vou criar um projeto novo e esse projeto novo vai consumir meu pacote
compartilhado. Meu pacote compartilhado será uma dependência desse projeto que eu vou criar.
Então, normalmente para instalar dependências a gente usa o comando NPM e install, mas como usar o
NPM install e em vez de obter o pacote do registro público oficial ele usar o verdade, o nosso registro
privado particular. Vamos ver. Então, eu vou aqui no terminal, eu vou abrir uma nova aba e criar
um novo, um novo pasta. Eu vou chamar de pacote consumidor. Eu vou ceder para pasta pacote
traço consumidor. Eu vou falar NPM net para poder criar um arquivo package.json. Package name
é o mesmo, versão pode ser um, sem descrição, perta enter, perta enter de novo, enter até acabar.
Eu não importo muito com as coisas porque é só diamostra. Pronto, deixa eu abrir o Atom aqui.
Então, temos aqui no lado direito da tela, eu abri acima o package.json não tem nenhuma dependência,
ainda. Então, eu vou falar NPM install, espaço meu traço pacote compartilhado. Agora, obviamente,
aperta enter, ele vai tentar obter esse pacote do registro público oficial do NPM, NPM.js.com.
Em vez de para você poder mudar o registro de consumo de pacotes, é só aplicar a opção traço
pass, registry, espaço e a URL. No meu caso, aqui 0000 na porta 4873. Então, vou copiar aqui
o pegador e vou colar no meu terminal a HTTP 2.0.0.0.0.2.4873 e vamos ver o que acontece.
Eu tenho o verdade rodando aqui, em outra aba eu tinha dado Docker compose app traço D. Então,
vamos ver se deu certo. Eu vou dar LS, ver que node modules apareceu. Vou aqui no meu editor de text para verificar
aqui no lado direito a node modules eu posso ver que tem meu pacote compartilhado e os arquivos eu
posso ver que tem aquele arquivo Rhythm, meu pacote Leia, muito da hora. E o package.json realmente mostra
aqui e foi resolvido o URL do verdade e realmente veio as coisas e a versão deve ser 01 como a gente
tinha publicado. Olha aqui o navegador, né? Se olhar no package.json, sobre as dependências,
dependencies, temos lá do esquerdo, nome da propriedade, nome do pacote meu, traço pacote traço
compartilhado e no lado direito temos qualquer circumflex, né? 01. Então, funcionou direitinho,
isso como se instalado verdade em vez do registro oficial. Basta adicionar a opção traço traço registry.
Certo? Então, por isso, é só ir até a próxima.


0018-08 Como Consumir uma Dependencia de NPM Vindo do Registro Particular Verdaccio (npm install)

Publicação e Instalação de Pacote Implícita com publishConfig e .npmrc – Registro Verdaccio

# Resumo da Aula sobre Registro Particular de NPM

Olá pessoal! Nesta aula do Verdátil, aprendemos a definir um registro para o repositório do seu pacote, evitando a necessidade de digitar a opção `--registry` em todos os comandos NPM.

## Passos Apresentados:

1. **Remoção da Dependência**:
   - Usamos o comando `npm uninstall meu pacote compartilhado --registry <URL>` para remover a dependência atual do pacote.

2. **Configuração do package.json**:
   - Para evitar a repetição do comando `--registry`, vamos adicionar uma nova propriedade ao `package.json` do projeto consumidor.
   - A propriedade a ser adicionada é `publishConfig`:
     ```json
     {
       "publishConfig": {
         "registry": "<URL do Verdátil>"
       }
     }
     ```
   - **Nota**: Essa configuração se aplica somente para publicações, não para consumo.

3. **Teste de Publicação**:
   - Ao realizar `npm publish` no pacote compartilhado, verificamos que a versão foi atualizada corretamente.

4. **Uso do arquivo .npmrc**:
   - Para consumir pacotes do registro privado, a solução final foi criar um arquivo chamado `.npmrc` no pacote consumidor:
     ```
     registry = <URL do Verdátil>
     ```
   - Com isso, ao executar `npm install meu pacote compartilhado`, o pacote foi instalado corretamente, evidenciado pela presença do URL do Verdátil no `node_modules`.

## Conclusão:
Para simplificar o uso do registro privado do Verdátil, você pode optar por configurar o `.npmrc` para a instalação de pacotes, ou a propriedade `publishConfig` para publicações. Isso elimina a necessidade de digitar o parâmetro `--registry` repetidamente.

Olá pessoal, estamos de volta com mais uma aula do Verdátil, registro particular de
NPM.
Aprendemos como publicar um pacote e aprendemos também como consumir um pacote do Verdátil.
Agora vamos ver como se define um registro para o seu repositório.
Isto é, a gente não precisa mais, não quer mais sempre ter que digitar traço-traço registry
toda vez que fazer o comando de NPM.
Então como fazer isso?
Peia várias maneiras e vou te mostrar uma maneira através do package.json.
Tenho aqui este projeto do pacote consumidor que consume meu pacote compartilhado como
dependência.
Deixa eu só remover para a gente poder instalar de novo de outra maneira.
Vou dar NPM uninstall meu pacote compartilhado traço-traço registry espaço ao URL.
Agora não tem mais aquela dependência, foi removido aqui na linha 11 do package.json.
Agora a gente quer fazer a mesma coisa, NPM install meu pacote compartilhado, mas a gente
não quer mais ter que digitar sempre traço-traço registry espaço ao URL.
Vamos lá para o package.json do seu projeto que consome os pacotes.
Eu vou adicionar a propriedade.
Na final aqui depois a nova linha 12, não se esqueça da vírgula antes na linha 11,
no final.
Vamos adicionar essa propriedade que eu vou chamar de publish config em cramlcase, o c do
config é maiúsculo e define um objeto aqui e dentro desse objeto registry é o nome da
propriedade e você vai dar o URL nesse caso do verdade que eu vou copiar no meu terminal.
Então na verdade é como se a gente tivesse usado registry e a opção corresponde ao
nome da propriedade e o valor aqui no lado esquerdo.
Tá bom?
Então vamos testar.
Deixa eu ver aqui se não vai dar nenhum problema.
NPM install meu pacote compartilhado sem opção traço-traço registry.
Eu salvei o package.json lá.
Opa, não encontrou.
Então ele tentou usar o NPM mesmo.
Então deixa eu ver aqui esse que tá publish config e isso significa só da publicação.
Então eu acho que esse é só para publicação.
Deixa eu ver aqui no pacote no outro pacote aqui.
No meu pacote compartilhado, vamos ver.
Eu vou abrir o adlon.
No meu pacote compartilhado aqui abaixo à esquerda.
Já tá na versão 102.
Deixa eu botar versão 101.
Agora vai para versão 102.
Eu quero ver aqui, eu vou na verdade copiar o publish config com a propriedade registry
para o package.json do meu pacote compartilhado.
Porque se eu ler o nome da propriedade realmente fala publish que é publicar.
Então acho que funciona para publicar, não para consumir.
Vamos testar.
Deixa eu ver aqui.
Adicionei a vírgula, tudo certo.
Para o meu pacote compartilhado, eu vou falar NPM publish.
Eu vou falar atrás de dryrun para ver no que dá.
Meu pacote foi 102 e tal e tal e tal.
Eu vou tirar o dryrun.
E eu falei NPM publish, vamos lá na verdade ver se realmente mudou.
Realmente mudou, a versão apareceu atualizada aqui para 102.
Certo?
Então me desculpe, inicialmente esse publish config no package.json é para publicar,
não é para consumir.
Tá? Do pacote que é para publicar.
Então, revisando de novo.
Você tem um pacote que você quer publicar para o verdade, o seu registro particular.
E você não quer ter que falar NPM publish com aquela opção traço-traço registry.
O que fazer?
Adiciona a propriedade publish config ao seu package.json e dentro desse object,
uma nova propriedade registry com o valor é a URL do verdade.
Com isso não precisa ter mais opção traço-traço registry explícita,
toda vez falar NPM publish.
Agora vamos no lance do pacote lá consumidor.
Vamos aqui.
Vamos olhar outra maneira aqui.
Como o publish não funcionou, eu vou tirar, tá?
Eu vou criar um arquivo chamado .npmrc,
arquivo .npmrc na parte do pacote traço-consumidor,
que ele consume o meu pacote compartilhado.
E dentro disso eu vou falar o seguinte,
eu vou falar registry igual ao URL do verdade.
HTTP, dois pontos, barra-barra, no meu caso, 0.0, 0.0, 0.0, 2 pontos, 48, 73.
Vou saber aqui o ponto NPMrc.
Vou lá no terminal, vamos tentar novamente na outra aba do pacote consumidor,
e vou tentar NPM install no meu pacote compartilhado.
Agora instalou versão 1.0.2,
vamos lá no node modules do pacote consumidor,
meu pacote compartilhado apareceu.
Vou falar no node que tem o resolved e tem o URL do verdade.
Tá bom? Então o package de versão aparece,
o meu pacote compartilhado de novo.
Então no caso do seu projeto,
que quer consumir um pacote do registro privado particular do verdade,
cria um arquivo .npmrc, adicione a chave-valor,
nesse caso registry igual ao URL do verdade.
Pronto?


0018-09 Publicação e Instalação de Pacote Implícita com publishConfig e .npmrc – Registro Verdaccio

Instalação de Pacotes do Registro Público do NPM Através do Proxy do Verdaccio

# Resumo da Transcrição

Nesta sessão, o apresentador discute a configuração de um registro de pacotes utilizando o Verdaccio e suas interações com o registro oficial do NPM. 

## Tópicos Abordados

- O apresentador modifica o registro de um pacote consumidor e investiga como funciona a instalação de pacotes que não estão disponíveis localmente.
- Ao executar `npm install`, ele percebe que existem muitas dependências e que o processo pode ser demorado, especialmente quando não há módulos do Node ou cache previamente armazenados.
- Durante a instalação, ocorre um erro 500, trazendo à tona problemas de conectividade com o uplink do Verdaccio, que deve redirecionar requisições para o registro NPM oficial.
- O apresentador realiza uma investigação nos logs do Docker e na configuração do Verdaccio, verificando que as opções do uplink (URL do NPMJS) estão corretas.
- Após algumas tentativas, ele encontra sucesso ao tentar instalar o pacote `lodash`, indicando que o problema pode estar vinculado a um pacote específico e não ao Verdaccio em geral.

## Conclusão

O procedimento de proxy para pacotes que não estão disponíveis localmente parece estar funcionando como esperado, com a instalação do pacote `lodash` indo corretamente para o registro NPM. A sessão termina de forma aberta, convidando os ouvintes a interagir e compartilhar conhecimentos sobre problemas semelhantes.

Agora para terminar vamos explorar. Tá aí pronto nós mudamos o registro esse pacote
consumidor mas e aí como faz provavelmente o meu pacote consumidor tem outras dependências
que não está na verdade mas na verdade está no registro publico oficial. Será que funciona
vamos explorar a gente da NPM install em algo que não está na verdade. Se eu for aqui na parte
do pacote consumidor da NPM install por exemplo se eu estar lá deixa eu ver.
Node.
Vamos ver no que dá.
E valei NPM install node.
Já vi aqui que ele apareceu versão 207. Obviamente o nosso verdade não tem node.
Então eu acho que ele realmente vai bater lá no registro publico oficial.
Deixa só terminar para eu confirmar.
E aí.
Demora. Parece que o pacote que eu instalei depende de muitos outros
pacotes. Isso é uma das das coisas do ecossistema de NPM que dá dor de cabeça.
As dependências são dezenas se não centenas se não às vezes milhares.
Então para resolver tudo isso o processo de resolver demora um pouco ainda mais que eu
comecei de usar sem nenhum node module.
Aqui e.
Sem nenhum node module e sem nenhum cache.
Então vamos ver aqui NPM install o que aconteceu.
Deu 500 em torno de error.
Por que será que deu esse problema.
Será que foi verdade. Vamos investigar.
Eu estou aqui.
Desculpa. Eu estou aqui na parte do verdade eu quero dar um lado no log do docker.
Eu vou falar docker logs. Mas eu tenho que ter o nome do.
Contênei que é esse aqui.
Ah. O que é que foi aqui.
Então tem vários erros de fazer o get.
RedStream NPM JTS não sei o que.
E deu.
Está dizendo que o uplink está offline.
172.
O que.
Então o HTTP recebeu 500 do uplink está offline.
Será que realmente caiu ou foi verdade mesmo.
Deu problema. Deixa eu tentar novamente.
Então deu problema de novo.
Então parece que dar algo errado aqui no verdade.
Vamos dar um lado nesse uplink.
Aqui talvez tenha.
Problema. Deixa eu ir no navegador e vamos precisar.
Eu vou lá para a página do verdade. Deixa eu ver se tem aqui o link.
Não tem. Então vou abrir.
Verdade.
Então na página verdade.org.
VRDACCIO.org.
Eu vou procurar para o negócio chamado uplink.
UPLINK.
U.
Deixa eu ver aqui.
Configuração.
Uplink.
Uplink é um link para um registro externo que for nesse acesso a pacotes externos.
Nesse caso está mostrando diagrama do verdade você pode ir para o NPM registry ou o YARN ou outros.
Usagem.
O uso é uplink. Tem essa propriedade no arquivo YAML.
Configuração.
Tem o nome. NPMJS e a URL.
Configuração.
Propriedade de autenticação.
E tal e tal. Vamos ver aqui o que fazer.
Eu vou para a pasta do verdade.
Temos aqui docle compose e tal.
Vamos ver aqui uma coisa.
Se eu for docker exec para suiter.
Verdade.
VRDACCIO.org.
VRDACCIO.org.
Se eu dar o cat no config YAML.
O que aqui tem aqui?
Tem uplinks.
O que aqui é definido por padrão no container uplinks.
NPMJS.
URL.
Se eu conferir aqui no site do lado esquerdo no navegador que está atrás.
A configuração está correta.
Então por que será que está dando problema?
Pacotes.
Deixa eu ver esse pacote.
Estar.
Permita todos os usuários, incluindo os que não estão autenticados a ler e publicar todos os pacotes.
Você pode especificar os usuários, os uninhos, o nome de grupo.
Tem um acesso da dólar all todos.
Publicar autenticado.
Despublicar autenticado.
Proxy NPMJS.
Se o pacote não está disponível localmente.
Proxy, requisições de proxy para NPMJS e registro.
Proxy está aqui mesmo.
NPMJS que aparece lá no uplinks.
Então deveria funcionar.
Deixe-me dar uma olhada aqui nesse log.
LES.
Deixe-me ir para o final.
HD.
No final daqui com Shift G, no LES.
Que foi que aconteceu?
Silly Save Tree, não sei o que, não sei o que, quando chegou.
Erro de servidor interno para o Cacheable Request, é são seis.
O que tem pacote aqui?
Meio estranho.
Número de Módio de Barra de Pacote.
Deixe-me tentar o outro.
Não sei se está problemático mesmo.
Deixe-me dar a Low Dash.
NPM está a Low Dash.
Então funcionou.
Não sei porque o outro deu problema.
Tem alguma coisa estranha lá.
Deu algum problema lá de...
Não sei, nem se foi até o código do NPM próprio.
Porque eu vi aquele negócio, se você lembra, aquele negócio de...
No final, Shift G grande, mas eu...
Eu vejo o nome pacote aparecer aqui.
Isso parece ser uma operação de Split, de visão de I String.
Lá do esquerdo é pacote, lá direito sendo consumidor.
E não apareceu.
Não sei porque está inclinando aqui, não sei o que aconteceu aí.
Você vê pacote, traz consumidor.
E de repente pareceu pacote muito estranho.
Ela parava de pacote português aqui.
E qual que é a maneira?
Acho que aquele erro só foi do pacote lá.
Eu não sei.
Tinha que investigar mais.
Se você sabe o que aconteceu isso, seria legal você compartilhar.
Então é isso.
O NPM install load-as, e funcionou direitinho.
Ele fez proxy para o NPM JS, como a gente tinha visto lá na config em Emon,
que está dentro do container, que já está aqui na configuração que vem.
Como padrão, o uplink, o NPM JS, o URL, e o RL do registro do NPM.
E quando o pacote não existe no verdade, no seu registro particular,
ele vai procurar no registro público que foi especificado aqui na opção padrão.
O proxy é o NPM JS.
Para qualquer pacote.
Se o Strelas terá significado, vai selecionar qualquer nome de pacote,
enquanto esse outro que é pacote que começa com o Arroba, o At,
senão o At.
Eu vou sair essa coisa.
E por essa aula é só.
E até a próxima.
