O que é TabNine​

TabNine é o derradeiro add-on de desenvolvimento, oferecendo sugestões de código em tempo real para o ajudar a atingir a perfeição num instante. E com uma instalação fácil no Visual Studio Code, pode começar a tocar a sua sinfonia de código num instante.

TabNine é um virtuoso de programação, compreendendo o contexto do seu código para sugerir as melhores linhas de código. Isto pode ajudá-lo a evitar erros comuns e a escrever um código mais eficiente. Por exemplo, se estiver a escrever uma peça de código para iterar através de uma lista, TabNine pode sugerir as melhores opções para percorrer essa lista, tais como o laço "para" ou o método "mapa".

TabNine é também um compositor genial, sempre actualizado com as últimas tendências de desenvolvimento. Isto significa que pode contar com o TabNine para lhe dar as melhores sugestões, independentemente da versão da sua linguagem de programação que utilizar. E com o Visual Studio Code, tem um ambiente de desenvolvimento completo para tocar a sua sinfonia de código.

Instalando TabNine​

Para utilizar TabNine com Visual Studio Code, basta seguir estes passos simples:

• Abra o Código Visual Studio e vá para a secção Extensões.
• Pesquise TabNine na lista de extensões disponíveis.
• Clique em Instalar para agendar a extensão.
• Uma vez concluída a instalação, clicar em Activate para começar a utilizar o TabNine.
• Para utilizar TabNine, basta começar a digitar o código e seleccionar uma sugestão de código a partir da extensão.

Uma vez instalado, terá de criar uma conta TabNine para tirar partido de todas as características desta ferramenta de desenvolvimento. Isto leva apenas alguns minutos e permitir-lhe-á beneficiar de todas as sugestões em tempo real e actualizações constantes da TabNine. Por isso não espere mais e adicione hoje o TabNine ao seu ambiente de desenvolvimento do Visual Studio Code!

TabNine e Visual Studio Code são as ferramentas de desenvolvimento perfeitas para compor a sua sinfonia de código. Com sugestões em tempo real, compreensão do contexto, actualizações constantes e um ambiente de desenvolvimento completo, pode criar peças épicas de desenvolvimento em pouco tempo. Portanto, não espere mais e deixe a sua paixão pela programação fluir com TabNine e Visual Studio Code.

O que é o t?​

Um Dockerfile é um documento de texto que contém todos os comandos que um utilizador poderia chamar na linha de comando para montar uma imagem. Utilizando a construção da doca os utilizadores podem criar uma construção automática que executa sucessivamente várias instruções de linha de comando.

Tal como o Vagrant que usa um ficheiro vagabundo para criar e personalizar uma máquina virtual de acordo com as suas necessidades, o Docker usa um ficheiro de doca para criar e personalizar um contentor! Podem ser semelhantes, mas são muito diferentes! (pode aprender como usar o Vagrant para criar um Windows Server vm aqui)

Como já foi dito anteriormente, para este exemplo, vamos criar um recipiente de rubi com mdl instalado. Por isso, precisamos de começar o nosso ficheiro portuário:

FROM ruby:latest

FROM cria uma camada a partir da última imagem Ruby Docker.

FROM ruby:latest

WORDIR /mdl

A instrução WORDIR define o directório de trabalho para qualquer instrução RUN, CMD, ENTRYPOINT, COPY e ADD que a siga no Dockerfile. Se o WORKDIR não existir, será criado mesmo que não seja utilizado em qualquer instrução subsequente do Dockerfile.

FROM ruby:latest

WORDIR /mdl
RUN gem install mdl

O RUN tem 2 formas:

• comando RUN (forma shell, o comando é executado numa shell, que por defeito é /bin/sh -c no Linux ou cmd /S /C no Windows)
• RUN ["executável", "param1", "param2"] (formulário exec)

No nosso exemplo, a RUN executa um comando que instala MDL directamente no contentor de rubi

FROM ruby:latest

WORDIR /mdl
RUN gem install mdl

ENTRYPOINT [ "/bin/bash" ]

ENTRYPOINT, tal como RUN, tem 2 formas! Forma Shell ou forma executiva.

A forma exec, que é a forma preferida:

ENTRYPOINT ["executável", "param1", "param2"]

A forma da concha:

ENTRYPOINT comando param1 param2

No nosso caso, estamos a utilizá-lo de forma executiva para que possamos executar a nossa bash. Isto deixará o nosso contentor aberto porque a bash está a funcionar em segundo plano.

Por isso, agora que temos o nosso ficheiro portuário, temos de construir o nosso contentor a fim de o executar!

docker build --tag user/mdl

O comando ---tag* nomeia a imagem do recipiente em questão. E agora que o contentor está construído, podemos executá-lo!

Para tal, será utilizado o seguinte comando:

docker run -tid --name mdl -v /home/vagrant:/mdlfiles user/mdl

Para ter a certeza se o seu contentor está a funcionar correctamente, faça um simples ``docker ps -a```` apenas para ter a confirmação. Ao fazê-lo, irá mostrar-lhe todos os detalhes e estado do seu contentor.

Após confirmar que o contentor está a funcionar, queremos executar mdl* para verificar o nosso ficheiro de marcação. Para o fazer, teremos de executar o comando mdl dentro de uma bash que irá obter o ficheiro .md dentro da pasta que partilhámos e a que demos o nome de "mdlfiles".

docker exec mdl bash -c "mdl /mdfile/myfile.md"

Se tiver algumas inconsistências em relação às regras da ferramenta mdl, obterá um resultado como este:

/mdfile/docker.md:5: MD009 Trailing spaces
/mdfile/docker.md:77: MD009 Trailing spaces
/mdfile/docker.md:25: MD012 Multiple consecutive blank lines
/mdfile/docker.md:51: MD012 Multiple consecutive blank lines
/mdfile/docker.md:13: MD013 Line length
/mdfile/docker.md:52: MD013 Line length
/mdfile/docker.md:54: MD013 Line length
/mdfile/docker.md:89: MD024 Multiple headers with the same content
/mdfile/docker.md:19: MD026 Trailing punctuation in header
/mdfile/docker.md:26: MD026 Trailing punctuation in header

Depois de os corrigir a todos, não deverá ter retorno após o seu comando! :)

Antes de começar​

Por favor, certifique-se de que verificou o meu posto Docker anterior, porque vou utilizar algumas referências a esse posto, e seria mais fácil seguir este posto :)

Neste caso, estará a utilizar um recipiente de rubi para instalar a nossa ferramenta mdl. Mostrará como instalar um contentor de rubi nesse post anterior do Docker que mencionei.

Markdown Lint​

Esta é uma ferramenta para ficheiros Markdown (md) que inclui uma biblioteca de regras para encorajar normas e consistência para ficheiros Markdown e que confirma se os ficheiros estão a seguir estas regras.

Contentor Ruby​

Por isso, para começar, vamos correr o contentor de rubi! Copie colar a seguinte linha no seu terminal:

docker run -tid -v /home/vagrant:/mdfiles --name ruby --entrypoint=/bin/bash ruby:latest

Muito bem, então olhe para esta linha de comando e pergunte-se o que no mundo é tudo isto!? Bem, deixe-me explicar :)

A -tid é 3 coisas diferentes:

-t ou --tty: Atribuir um pseudo-TTY -i ou --interactiva: Manter STDIN aberto mesmo que não anexado -d ou --detach: Modo destacado: comando de execução em segundo plano

Depois, fazemos um -v de volume, que no nosso caso, é utilizado para espelhar a pasta onde temos o nosso ficheiro .md. Isto permitir-nos-á ter "a mesma pasta" no nosso contentor. Lembre-se que o / é a raiz e depois criamos uma nova pasta no contentor chamada "mdfiles".

Depois utilizamos o --nome e como o nome sugere é para attibuir um nome para o seu contentor.

Corremos --oponto de entrada /bin/bash para deixar abrir uma cave. Isto permite que o contentor fique aberto (para cima) em vez de fechar logo após a corrida. Quando se faz um executante, este não vai à batida (execut é sh e não bash). É por isso que temos de fazer com que o contentor funcione bash, para podermos usar todo o comando bash

A diferença entre a execução da doca e a execução da doca é que a doca executa um comando sobre um contentor em execução. Por outro lado, a docker run cria um contentor temporário, executa o comando no mesmo e pára o contentor quando este é $ Então usamos --entrypoint para correr um contentor, e deixamo-lo abrir até decidirmos pará-lo

Também pode dar um comando directamente ao seu contentor, ao fazê-lo: Nota: Se tiver um contentor com janelas, usa o powerhell em vez de bash

docker exec ruby bash -c "ip add"

Executamos o terminal bash com o comando (-c) "ip add". Isto mostrar-lhe-á o endereço IP do seu contentor de rubi

E agora podemos instalar a ferramenta mdl:

docker exec ruby bash -c "gem install mdl"

Óptimo, tudo parece agradável e limpo! Agora, escolha um ficheiro .md à sua escolha, e execute o mdl:

docker exec ruby bash -c "mdl /mdfiles/myfile.md"

Isto fará correr a ferramenta mdl através do seu ficheiro md e informá-lo-á de quantos erros tem, as linhas que são e qual foi a regra que não foi respeitada.

O que é isso ?​

Como explicado em opensource.com Docker é uma ferramenta concebida para facilitar a criação, implementação e execução de aplicações através da utilização de contentores. Os contentores permitem a um programador empacotar uma aplicação com todas as partes de que necessita, tais como bibliotecas e outras dependências, e implementá-la como um pacote. Ao fazê-lo, graças ao contentor, o programador pode ter a certeza de que a aplicação será executada em qualquer outra máquina Linux, independentemente de qualquer configuração personalizada que a máquina possa ter que possa diferir da máquina utilizada para escrever e testar o código.

De certa forma, o Docker é um pouco como uma máquina virtual. Mas ao contrário de uma máquina virtual, em vez de criar todo um sistema operativo virtual, Docker permite que as aplicações utilizem o mesmo kernel Linux que o sistema em que estão a correr e apenas requer que as aplicações sejam enviadas com coisas que ainda não estejam a correr no computador anfitrião. Isto dá um impulso significativo ao desempenho e reduz o tamanho da aplicação.

Como utilizá-lo​

Para podermos gerir um recipiente, precisamos de o ter disponível para nós. Assim, para começar precisamos de puxar o contentor procurado e para isso vamos a DockerHub.

Para o exemplo vou usar um contentor Nginx e um Grafana.

Digite no seu terminal (onde correu o seu ficheiro vagabundo) o seguinte comando:

Nginx:

docker pull nginx

Consulte a página do DockerHub Nginx para mais detalhes aqui

Grafana:

docker pull grafana/grafana

Consulte a página do DockerHub Grafana para mais detalhes aqui

Agora que puxámos os recipientes, eles estão "instalados" na sua máquina para que possa utilizá-los.

Mas agora temos de gerir os nossos contentores e temos de os atribuir com portos específicos. Para o fazer, precisamos de utilizar o comando -p.

Portanto, vamos verificar como gerimos um contentor que temos disponível e como lhe atribuímos um número de porta à nossa escolha. Para isso, copie colar a seguinte linha no seu terminal:

docker run -d --name=grafana -p 3000:3000 grafana/grafana

Isto irá funcionar no Grafana no porto 3000. Para confirmar isto, precisaremos de ir à sua corretora e tyoe 127.0.0.1:3000 Ao fazê-lo, deve abrir o site pessoal do Grafana.

Note que quando o faz -p 3000:3000 o segundo número é o porto designado no seu anfitrião. a opção é "-p container_port_number:host_port_mapped". Por exemplo, se fizermos -p 3000:6000 então o ip para o seu site grafana será 127.0.0.0.1:6000

TIP: Se fez tudo isto e ainda teve um erro ao abrir a página web, vá verificar as suas preferências VM na VIrtualBox e certifique-se de que adiciona a porta 3000 no Port Redirections. Para chegar ao Port Redirections basta abrir a VirtaulBox, vá à configuração do seu Docker VM à parte Network. Encontrará uma secção Advance e lá dentro estará o Port Redirection. VB > Configuração VM > Rede > Avanço > Redireccionamento de Portas

Interrested ? Siga o guia!

Actualização: Typora não é um software de código aberto, e apenas a versão beta parece ser livre. Se a adopção de hábitos num software gratuito para software pago mais tarde o aborrece, sugerimos a utilização de um clone typora de código aberto: MarkText.

MarkText, From Markdown, with Love​

Esta ferramenta chama-se typora, e o site oficial está lá: typora MarkText

Apresento-vos esta ferramenta que irei testar para a série de artigos em torno do gitlab CI / CD.

Está disponível para Windows, Linux, e Mac OS.

Obtenha o poder de Markdown, sem utilizar Markdown​

As características do editor fornecem-lhe o poder do formato markdown, porque é possível guardar ficheiros directamente em markdown, mas também copiar o texto em formato markdown.

What You See Is What You Get​

Aqui está o artigo, na sua versão em francês, aberto com typora. (MarkText teria exactamente o mesmo resultado)

Pode aplicar o estilo que desejar (Header 1-2-3, bold, etc. ) seleccionando-o no menu, ou utilizando os atalhos padrão (CTRL+B, CTRL+I)

Guardar em Markdown​

Só tem de guardar o ficheiro com marktext (apenas .md está autorizado) ou escolher markdown com typora (que propõe também .txt)

Conteúdo da remarcação para exportação​

Typora MarkText permite-lhe exportar (ou copiar) uma parte do documento, directamente com a sintaxe de markdown.

Aqui está o resultado da exportação com a versão em francês do artigo:

Un éditeur WYSIWYG pour éditer des fichiers Markdown ?

Si ça vous intrigue, suivez le guide !

# Typora, par amour du markdown

C'est outil s'appelle typora, et le site officiel est là: [typora](https://typora.io/)

Je vous présente cet outil que je vais tester pour la série d'article autour de gitlab CI/CD.

Il est disponible pour Windows, Linux, et en version beta (à l'heure d'acriture de ces lignes) pour Mac OS.

## Des fonctionnalités pour profiter de la puissance du markdown

Les fonctionnalités de l'éditeur permettent de profiter de la puissance du format markdown, car il est à la fois possible de sauvegarder des fichiers directement en markdown, mais également de copier le texte au format markdown.

### Un éditeur wysiwyg

Voici, par exemple, le rendu de cet article (dans sa version française)

Só tem de seleccionar a peça que pretende exportar, e utilizar a entrada do menu, ou utilizar o atalho: CTRL + MAJ + C (o atalho funciona tanto em typora como em marktext)

Corrector ortográfico​

Presumo que saibam do que estou a falar.

Qualidade Markdown​

Utilizamos, para garantir a qualidade da sintaxe dos nossos ficheiros markdown, uma ferramenta chamada markdownlint. A versão em francês do post obteve esse resultado:

$ mdl content/posts/*.md --ignore-front-matter --rules ~MD013,~MD026,~MD033
content/posts/typora_fr.fr.md:13: MD009 Trailing spaces
content/posts/typora_fr.fr.md:15: MD009 Trailing spaces
content/posts/typora_fr.fr.md:21: MD009 Trailing spaces
content/posts/typora_fr.fr.md:23: MD009 Trailing spaces
content/posts/typora_fr.fr.md:27: MD009 Trailing spaces
content/posts/typora_fr.fr.md:39: MD009 Trailing spaces
content/posts/typora_fr.fr.md:45: MD009 Trailing spaces
content/posts/typora_fr.fr.md:47: MD009 Trailing spaces
content/posts/typora_fr.fr.md:50: MD009 Trailing spaces
content/posts/typora_fr.fr.md:52: MD009 Trailing spaces
content/posts/typora_fr.fr.md:58: MD009 Trailing spaces
content/posts/typora_fr.fr.md:60: MD009 Trailing spaces
content/posts/typora_fr.fr.md:64: MD009 Trailing spaces
content/posts/typora_fr.fr.md:75: MD009 Trailing spaces
content/posts/typora_fr.fr.md:81: MD009 Trailing spaces
content/posts/typora_fr.fr.md:82: MD009 Trailing spaces
content/posts/typora_fr.fr.md:84: MD009 Trailing spaces
content/posts/typora_fr.fr.md:96: MD009 Trailing spaces
content/posts/typora_fr.fr.md:100: MD009 Trailing spaces
content/posts/typora_fr.fr.md:109: MD009 Trailing spaces
content/posts/typora_fr.fr.md:35: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:36: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:90: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:91: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:105: MD012 Multiple consecutive blank lines
content/posts/typora_fr.fr.md:106: MD012 Multiple consecutive blank lines

A sintaxe de markdown parece ser boa. A única coisa que não é fixada pela ferramenta são as regras que dizem respeito a espaços duplos, espaços no fim das linhas, linhas em branco duplas, etc.

Numa palavra: tudo o que se pode VER no wySiwyg.

O propósito da utilização do Marktext/Typora​

Postagens de websites de Hugo​

O MarkText é muito útil para escrever o conteúdo de texto do sítio de Hugo, gosta de posts ou descrições de autores.

Por exemplo, pode simplesmente copiar o conteúdo MD no editor web gitlab/github, colá-lo no Marktext, modificá-lo, e copiar como MD para o colar novamente no editor gitlab/github.

Também pode gerir o foder de conteúdo directamente na ferramenta, mas terá de usar o gitlab/github em bash para empurrar a sua modificação no repositório gitlab/github:

As nossas ferramentas​

Estamos a utilizar um conjunto de ferramentas baseadas em (ou conformes com) markdown:

• Wikis;
• READMEs de código de base;
• Base de Conhecimento;
• Relatórios de Decisão de Arquitectura

A ferramenta de exportação (também conhecida como copy as markdown) é muito útil para poder editar texto como num editor de texto padrão, mas poder usar o poder de markdown quando se pretende alterar a estrutura de um texto. Este caso aparece normalmente quando se edita um wiki ou uma página kb. Quanto mais acrescentarmos, mais precisamos de rever a estrutura.

Conclusão​

Vou começar os artigos sobre o gitlab CI/CD com Marktext, e, para ser honesto, penso realmente que vou voltar a um editor MD.

Mas tenho de confessar que é uma grande ferramenta para aqueles que querem obter o poder do Marktext sem aprender/exercitar a sintaxe. E não tenho a certeza absoluta de que voltarei a um editor padrão depois de adquirir hábitos no Marktext...

Chocolatey:​

Chocolatey é um módulo para o Windows instalar pacotes (ferramentas) na máquina. Também conhecida como ferramenta de gerenciamento de software.

Chocolatey nos permite executar várias tarefas através linha de comando.

Por exemplo, "choco install aplicação" é o equivalente a "apt install aplicação" no Ubuntu.

Portanto, para instalá-lo, precisas copiar e colar a linha de comando seguinte no teu terminal:

config.vm.provision "shell", inline: <<-SHELL

  Set-ExecutionPolicy Bypass -Scope Process -orce; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

SHELL

This command will install chocolatey and allow you to use "choco install" to install other tools into your windows machine such as Git or VSCode.

Exemplo:​

Digamos que desejas instalar algumas ferramentas necessárias e fazer isso com Chocolatey!

Portanto, no teu terminal, digita um dos seguintes comandos:

choco install git -y
choco install vscode -y
choco install hugo -y

Estes comandos instalam as respectivas ferramentas (aplicação), mas podes instalar as ferramentas que desejas. A única coisa que precisas é choco install "ferramenta que desejas" :)

Nota que -y é responder Sim às perguntas feitas pelo processo de instalação;

O que é preciso?​

Usaremos duas ferramentas para tornar a implantação da vm Ubuntu muito rápida!

Essas ferramentas são Vagrant e Virtual Box.

Instalação​

Via Download​

Nota que podes escolher o sistema operacional em que deseja instalar a ferramenta (Linux, Windows, etc ...)

• Vagrant -> download Vagrant

• Virtual Box -> download Virtualbox

Usando o gerencidor de pacotes (package management)​

Windows - Chocolatey​

Para começar, precisas instalar o Chocolatey. Para isso, tenho um post que explica como fazê-lo corretamente aqui -> Chocolatey

Agora que Chocolatey está instalado, vamos usá-lo.

Vamos começar com o VirtualBox, portanto, para isso, usa a linha de comando seguinte:

choco install virtualbox

E agora, Vagrant:

choco install vagrant

Linux - apt​

Esse é o mesmo conceito que o choco install, mas para o Linux, é claro.

Portanto, no Linux, usaremos apt install.

VirtualBox:

sudo apt install virtualbox

Vagrant:

sudo apt install vagrant

Deployment​

Então, primeiro precisamos da caixa do Vagrant (não te esqueças de ver o post sobre Vagrant na página para aprender um pouco mais sobre as caixas do Vagrant).

Neste exemplo, usaremos o Ubuntu 18.04 LTS

Agora, na tua máquina local, acessa o teu terminal, cria uma pasta para a caixa do Vagrant (box) e, dentro da nova pasta, digita:

vagrant init ubuntu/bionic64

Isto adicionará a caixa ao teu Vagrant local.

E agora, vamos criar a nossa máquina virtual Ubuntu! Então escreve no teu terminal:

vagrant up

E aí está! A tua primeira vm Ubuntu!

Continua a explorar os nossos posts para dicas ;)

Vamos precisar de Vagrant, Chocolatey, Git, Hugo e VSCode.

Vamos começar!

Vagrant​

Agora vamos ver como podemos criar um servidor para as nossas necessidades e desejos.

Primeiro, a VM. Decidimos ir com um sistema operacional Windows Server 2019 e, para isso, procuramos uma box (vagrant box) do Windows Server em vagrants box website

No site, basta escrever na caixa de pesquisa, o tipo de VM que queres (pode ser Linux, Windows, etc). No nosso caso, basta escrever "mcree / win2019".

Dentro da página da box, você encontrará "Vagrantfile" e "New". O interesse para este post é o "Vagrantfile".

Como podes ver na página da box, tem a configuração inicial do Vagrantfile. Vais precisar disso para criar (up) o teu servidor virtual.

Este é o começo do nosso fichiero Vagrant:

Vagrant.configure("2") do |config|
  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"
end

Como podes ver, temos a caixa para nossa vm e a sua versão.

Agora, vamos adicionar o nome da nossa vm e a quantidade de memória (RAM) que queremos atribuir:

wvm.vm.provider "virtualbox" do |v|
  v.name = "Windows Server 2019"
  v.memory = "2048"
end

Agora que temos o nome da nossa vm e a capacidade de RAM, vamos configurar a rede:

wvm.vm.define "Windows Server 2019" do |web|
  web.vm.hostname = "winserver19"
  web.vm.network "public_network"
end

Aqui, definimos o nome do host da vm e o tipo de rede que desejamos fornecer à vm (pública, privada, etc.)

Observa que existem várias variantes de configuração de rede; este post mostrará apenas a maneira mais básica de Up uma vm;

E o Vagrantfile está assim agora:

Vagrant.configure("2") do |config|
  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  wvm.vm.define "Windows Server 2019" do |web|
    web.vm.hostname = "winserver19"
    web.vm.network "public_network"
  end
end

É muito simples e fácil (exatamente como gostamos) configurar um Vagrantfile.

Mas queremos ter algumas ferramentas instaladas na vm quando criamos a nossa máquina virtual. Para fazer isso, vamos usar um terminal (shell).

Então, precisamos adicionar ao Vagrantfile o terminal:

config.vm.provision "shell", inline: <<-SHELL

SHELL

Este é o terminal que nos permitirá de dar comandos ao terminal para adicionar, remover, mover e um monte de outras coisas para a vm;

Então, vamos instalar o Chocolatey (vê abaixo a explicação chocolatey e como instalá-lo) e, usando o Chocolatey, vamos instalar o Git, VSCode e Hugo;

Repara que SHELL no final do terminal substitui o end nas outras configurações vistas anteriormente.

Chocolatey:​

Chocolatey é um módulo para o Windows instalar pacotes (ferramentas) na máquina. Por exemplo, "choco install tool" é o equivalente a "apt install tool" no Ubuntu.

Portanto, para instalá-lo, precisamos copiar e colar este comando no shell de vagrantfile:

config.vm.provision "shell", inline: <<-SHELL

  Set-ExecutionPolicy Bypass -Scope Process -orce; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

SHELL

Esta linha de comando instalará o chocolatey e permitirá que uses "choco install" para instalar outras ferramentas no servidor Windows, como Git ou VSCode.

Aplicações:​

Agora precisas instalar as ferramentas necessárias e usar o Chocolatey!

Portanto, adiciona ao teu shell de vagranfile os seguintes comandos:

choco install git -y
choco install vscode -y
choco install hugo -y

Estas linhas de comandos instalam as respectivas ferramentas, mas podes instalar as ferramentas que desejas e necessitas. A única coisa que precisas é choco install "ferramenta que desejas" :)

NOTA que - y é responder Sim às perguntas feitas pelo processo de instalação;

Então, o nosso Vagrantfile parece completo! Vamos ver como fica com todos os processos realizados juntos:

O Vagrantfile completo​

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  wvm.vm.define "Windows Server 2019" do |web|
    web.vm.hostname = "winserver19"
    web.vm.network "public_network"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -orce; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    choco install git -y
    choco install vscode -y
    choco install hugo -y

  SHELL

end

Mas deves precisa ter cuidado, pois o início rápido do documento oficial não é compatível com uma implantação no Gitlab Pages.

Como começar rapidamente com Hugo​

Aqui está a melhor forma de começar com Hugo na minha opinião:

Etapa 1 - Seleção de temas​

Primeiro, cuidadosamente escolhe o tema que desejas usar. Isto é importante porque a maneira como vais configurar o teu site pode ser (muito) específica para o teu tema.

Para escolher sabiamente, vai a themes.gohugo.io e assiste à demonstração dos temas que te interessam. Todas as demos integram a renderização da sintaxe de remarcação, o que garante que o tema atenda aos teus desejos!

Etapa 2 - Nome do site​

Segundo, escolha o nome do site. O nome do site tem que ser o mesmo da pasta que vamos cirar para implantar o teu site nas páginas do gitlab, terias o seguinte site URL: http: // username.gitlab.io / nomedapasta /

Se estás a criar um blog, "blog" seria um bom nome. Se o teu site servir para sugerir um produto, "productName" seria relevante.

Etapa 3 - Criação do site​

Esta é a parte mais simples do tutorial. Basta digitar a seguinte linha de comando:

hugo new site <nome da pasta>

Agora tens uma nova pasta chamada foldername com itens. Antes de fazer qualquer coisa, aplica o próximo passo. NÃO ENTRES NA NOVA PASTA

Etapa 4 - Download do tema​

Acede ao repositório do tema escolhido e NÃO CLONES o repositório git. Obtem o arquivo zip e descompacta-o em nome_da_pasta/themes/theme_name.

Observa que o conteúdo do tema deve estar em theme_name, não em theme_name/hugo-theme-name-master.

Etapa 5 - Usar exampleSite como modelo​

Copia o topic_name/exampleSite/config.toml diretamente para o teu nome da pasta, substituindo o ficheiro config.toml padrão.

No arquivo config.toml, altera a linha de seleção do tema para

theme = "<nome do tema>"

Como queremos usar o Hugo nas páginas do gitlab, também é necessário alterar o baseURL no config.toml:

baseurl = "https://<nomedousuário>.gitlab.io/<nome da pasta>"

Implantação de páginas do Gitlab​

Aviso​

NÃO FAÇAs NADA NO GIT! Vais criar um projeto gitlab que iniciará com o teu foldername

Etapa 6 - Criar um projeto gitlab​

No gitlab, cria um novo projeto, com o mesmo nome que a tua pasta. Não o inicializes com um arquivo README ou com o que seja.

Etapa 7 - Criar seu arquivo de IC​

Vai para o nome da tua pasta (a pasta criada anteriormente) e cria um arquivo chamado .gitlab-ci.yml

Edita o arquivo com o código seguinte:

image: monachus/hugo

variables:
  GIT_SUBMODULE_STRATEGY: recursive

pages:
  script:
  - hugo
  artifacts:
    paths:
    - public
  only:
  - master

Etapa 8 - Empurrar (Push) o site​

Primeiro, executa o repositório:

git init

Em seguida, adiciona o diretório /public ao arquivo .gitignore

echo "/public" >> .gitignore

Por fim, valida e envia o código na ramificação principal

git add .
git commit -m "Initial commit"
git remote add origin https://gitlab.com/YourUsername/your-hugo-site.git
git push -u origin master

Etapa 9 - Vizualiza e aguarda​

Acede ao "Pipeline de CI / CD" do teu repositório gitlab

Assiste à etapa de compilação e aguarda a aprovação. O teu site será publicado em nome de usuário.gitlab.io/nome de usuário

Para começar, vamos tentar compreender o que é o quê. Queremos instalar uma funcionalidade de janelas na nossa máquina/vm e queremos fazê-lo utilizando a possibilidade de automatizar todas as instalações e add-ons.

Para o fazer utilizando o Ansible, precisamos de utilizar módulos Ansible! E, neste caso, queremos usar win_feature módulo. Mas o que são módulos? Vamos ver:

Módulos​

Os módulos possíveis são reutilizáveis, scripts autônomos que podem ser utilizados pela API Possível, ou pelos programas de livros anáteis ou de livros-jogadores possíveis.

Podemos utilizar módulos para instalar, copiar, mover, descarregar e muitas outras acções. Há também muitos módulos diferentes, e digo muito!

Ansible tem módulos para Cloud, Database, Network, Monitoring, Windows, quase tudo o que se possa imaginar!

Mas para este post vamos focar apenas num módulo específico do Windows fornecido por Ansible que é win_feature módulo.

NOTE* que isto é apenas uma rápida visão geral do que são módulos! Pode consultar a documentação oficial do Ansible em Módulos para ter uma análise mais aprofundada.

Funcionalidade_vencedora​

Este módulo instala ou desinstala funções ou funcionalidades do Windows Server.

Mas, para saber qual a funcionalidade que queremos instalar, precisamos de encontrar o seu nome. E para isso usaremos um comando que listará todas as funcionalidades com a informação adicionada, se estão instaladas ou não.

Por isso, escreva no seu terminal o seguinte:

Get-WindowsFeature

Isto deve devolver uma lista completa das características:

PS C:\> Get-WindowsFeature

Display Name                                            Name                       Install State
------------                                            ----                       -------------
[ ] Active Directory Certificate Services               AD-Certificate                 Available
    [ ] Certification Authority                         ADCS-Cert-Authority            Available
    [ ] Certificate Enrollment Policy Web Service       ADCS-Enroll-Web-Pol            Available
    [ ] Certificate Enrollment Web Service              ADCS-Enroll-Web-Svc            Available
    [ ] Certification Authority Web Enrollment          ADCS-Web-Enrollment            Available
    [ ] Network Device Enrollment Service               ADCS-Device-Enrollment         Available
    [ ] Online Responder                                ADCS-Online-Cert               Available

(...)

[X] Web Server (IIS)                                    Web-Server                     Installed
    [X] Web Server                                      Web-WebServer                  Installed
        [X] Common HTTP Features                        Web-Common-Http                Installed
            [X] Default Document                        Web-Default-Doc                Installed
            [X] Directory Browsing                      Web-Dir-Browsing               Installed
            [X] HTTP Errors                             Web-Http-Errors                Installed
            [X] Static Content                          Web-Static-Content             Installed
            [X] HTTP Redirection                        Web-Http-Redirect              Installed
            [X] WebDAV Publishing                       Web-DAV-Publishing             Installed
        [X] Health and Diagnostics                      Web-Health                     Installed
            [X] HTTP Logging                            Web-Http-Logging               Installed
            [X] Custom Logging                          Web-Custom-Logging             Installed
            [X] Logging Tools                           Web-Log-Libraries              Installed
            [X] ODBC Logging                            Web-ODBC-Logging               Installed
            [X] Request Monitor                         Web-Request-Monitor            Installed
            [X] Tracing                                 Web-Http-Tracing               Installed
        [X] Performance                                 Web-Performance                Installed
            [X] Static Content Compression              Web-Stat-Compression           Installed
            [X] Dynamic Content Compression             Web-Dyn-Compression            Installed


(...)

[X] .NET Framework 4.7 Features                         NET-Framework-45-Fea...        Installed
    [X] .NET Framework 4.7                              NET-Framework-45-Core          Installed
    [ ] ASP.NET 4.7                                     NET-Framework-45-ASPNET        Available
    [X] WCF Services                                    NET-WCF-Services45             Installed
        [ ] HTTP Activation                             NET-WCF-HTTP-Activat...        Available
        [ ] Message Queuing (MSMQ) Activation           NET-WCF-MSMQ-Activat...        Available
        [ ] Named Pipe Activation                       NET-WCF-Pipe-Activat...        Available
        [ ] TCP Activation                              NET-WCF-TCP-Activati...        Available
        [X] TCP Port Sharing                            NET-WCF-TCP-PortShar...        Installed

(...)

Agora podemos ver uma lista completa de todas as funcionalidades do Windows (no exemplo acima só há algumas seleccionadas) com a informação adicional se estiverem instaladas ou não.

Esta pode ser uma óptima maneira de ver que características precisa de adicionar ao seu livro de jogo.

Agora, deixe-me mostrar-lhe uma forma de descobrir se uma funcionalidade que já conhece o nome está ou não instalada.

Para este caso, vamos procurar a funcionalidade .NET Framework. Iremos verificar o nome correcto da funcionalidade e se está ou não instalada.

Para isso, utilizaremos o comando abaixo:

Get-WindowsFeature | Where-Object {$_. name-match ".Net"} | Format-List Name,DisplayName, Installstate | more

Isto irá devolver o seguinte:

Name         : Print-Internet
DisplayName  : Internet Printing
InstallState : Available

Name         : Web-Net-Ext
DisplayName  : .NET Extensibility 3.5
InstallState : Installed

Name         : Web-Net-Ext45
DisplayName  : .NET Extensibility 4.7
InstallState : Installed

Name         : Web-Asp-Net
DisplayName  : ASP.NET 3.5
InstallState : Installed

Name         : Web-Asp-Net45
DisplayName  : ASP.NET 4.7
InstallState : Installed

Name         : NET-Framework-45-ASPNET
DisplayName  : ASP.NET 4.7                             #As you can see the feature is available, therefore not installed
InstallState : Available

Name         : BitLocker-NetworkUnlock
DisplayName  : BitLocker Network Unlock
InstallState : Available

Name         : Internet-Print-Client
DisplayName  : Internet Printing Client
InstallState : Available

Name         : Telnet-Client
DisplayName  : Telnet Client
InstallState : Available

Name         : WAS-NET-Environment
DisplayName  : .NET Environment 3.5
InstallState : Available

Name         : Wireless-Networking
DisplayName  : Wireless LAN Service
InstallState : Available

Agora que confirmamos o nome e o estado de instalação podemos adicionar ao nosso playbook.yaml o módulo win_feature de que falámos anteriormente no post.

Vamos dar uma olhada no playbook.yaml que contém o módulo win_feature*.

---
- name: Install Windows Features
  hosts: all
  tasks:
          - name: Install .Net Framework 4.5
            win_feature:
                    name: NET-Framework-45-ASPNET
                    state: present

Como pode ver, playbook.yaml instalará a mais recente funcionalidade .Net Framework Windows.

Vamos procurar a funcionalidade .net Framework no nosso terminal e ver o que mudou:

PS C:\> Get-WindowsFeature | Where-Object {$_. name-match "NET-Framework-45-ASPNET"} | Format-List Name,DisplayName, Installstate | more


Name         : NET-Framework-45-ASPNET
DisplayName  : ASP.NET 4.7
InstallState : Installed

E aí está! Instalámos com sucesso uma funcionalidade de janelas da nossa escolha, usando Livros de Jogar Ansíveis!

Agora, cabe-lhe a si ver qual a funcionalidade Windows que deseja instalar no seu servidor!

Lembre-se que pode fazer um playbook instalando tantas funcionalidades quantas desejar. Espero que este post o ajude a compreender um pouco melhor o módulo win_feature :)

Para começar, vamos dar uma vista de olhos a um simples ficheiro vagabundo contendo uma caixa do Windows Server 2019:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

  SHELL

Isto é apenas para lhe dar uma visão de um ficheiro vagabundo muito simples contendo apenas a caixa, o nome do vm, a memória RAM e um terminal de concha pronto a usar.

Vamos prosseguir!

Recarregar​

Para que serve carga ?

Bem, usar recarregar no seu ficheiro vagabundo é o mesmo que fazer uma reinicialização na sua máquina;

Portanto, vamos colocar isto em contexto;

Digamos que instalámos Chocolatey e queremos utilizá-lo para instalar o git.

Bem, isso é fácil, mas não podemos fazê-lo de imediato porque, uma vez que o vm não foi recarregado (reiniciado), não pode ter em conta a modificação feita anteriormente;

Por isso, para corrigir isto, precisamos de adicionar um dispositivo de recarga ao nosso ficheiro vagabundo!

config.vm.provision :reload

O comando acima é o que precisamos de acrescentar ao nosso vagrantfile* mas não o podemos utilizar se não estiver instalado.

Assim, para instalar o reload* porvisionador, abrir um terminal Powershell e digitar:

vagrant plugin install vagrant-reload

Isto instalará o plugin que lhe permitirá utilizar o reload provisionador no nosso ficheiro vagabundo;

Lembra-se do nosso simples ficheiro de vagabundagem? Vamos dar uma vista de olhos ao aspecto do ficheiro vagabundo com a instalação de Chocolatey:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

  SHELL

No nosso ficheiro vagabundo acima, instalamos Chocolatey. Mas, lembrem-se, queremos usá-lo para instalar as nossas ferramentas e sem recarregar o vm isto não será possível!

O que vamos fazer é, recarregar após a instalação de Chocolatey e depois de recarregar onde vai abrir um novo Provisor de terminal de Chocolatey para que possamos instalar Git usando Chocolatey;

Portanto, vamos dar uma vista de olhos ao nosso ficheiro vagabundo e ver como tudo isto funciona, colocando o Git em conjunto:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

  SHELL

  config.vm.provision :reload

  config.vm.provision "shell", inline: <<-SHELL

    choco install git -y

  SHELL

Óptimo! Conseguimos a instalação do plugin e a recarga bem sucedida do nosso vm !

Tamanho do disco​

Outro plugin útil é o TamanhoDisk*!

Este plugin permitir-nos-á gerir o tamanho do disco do nosso vm (todos os que usam o Vagrant sabem que esta é uma questão sensata :) )

Como vimos anteriormente, precisamos primeiro de instalar o plugin directamente na nossa máquina para o podermos utilizar no nosso ficheiro vagabundo.

Portanto, copiar colar o seguinte:

vagrant plugin install vagrant-disksize

Óptimo, o plugin está instalado e pronto para ser posto a funcionar!

Vamos ver como fica:

config.disksize.size = '40GB'

Como podem ver, quero ter um disco de 40gb de tamanho. mas onde o devemos colocar? Vamos dar uma vista de olhos a um ficheiro básico vagabundo:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

Muito simples e básico ficheiro vagabundo, mas falta qualquer coisa! Onde está o tamanho do disco*?

Bem, uma vez que faz parte da configuração do vm, vamos colocá-lo logo após a caixa do vm:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"
  wvm.disksize.size = "40GB"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

E aí está! Pode agora criar vm's com a quantidade de tamanho de disco que desejar :)

NOTE: Se iniciar o seu vm e verificar que o seu vm de janelas não tem o tamanho de disco que atribuiu e provavelmente só tem até 20gb de tamanho de disco.

A outra quantidade não é atribuída à partição certa. Para corrigir isto, vamos digitar o seguinte comando em uma Powershell: (não se esqueça no fim da linha de comando de adicionar o seu GB, no meu caso dei 40gb por isso vou colocar 39 no fim do comando)

Resize-Partition -DriveLetter C -Size 39gb

Espero vê-lo em breve no próximo post :)

É bastante desagradável ter encontrado O tema perfeito, e que falte uma simples funcionalidade. Por isso, decidi utilizar a gestão taxonómica nativa para registar vários autores num blogue. E, por enquanto, funciona bastante bem.

Para escrever este artigo, fui inspirado pelo seguinte tutorial: Como criar páginas de autor.

Estou a ter o cuidado de o completar apenas nos pontos em que tive de experimentar muito.

Usos das taxonomias​

Existem duas taxonomias padrão em Hugo:

• Etiquetas;
• Categorias.

Para utilizar as taxonomias padrão de Hugo, ou aquelas nativas do tema escolhido, é muito simples, basta adicionar o seguinte ao seu arquétipo:

---
tags:
- faire son site
- hugo-tips
categories:
- hugo
---

O princípio é simples: assim que adicionar uma categoria ou uma etiqueta, e o tema a gerir bem, encontrará uma http://[votresite]/tags/ e outra /catégories/ que listam etiquetas e categorias, e uma página por item listando os artigos que mencionam o item nos seus arquétipos.

Vejamos agora como criar uma nova taxonomia que abriria a possibilidade de adicionar um ou mais autores a um artigo.

Criar uma taxonomia​

Cada taxonomia tem dois modelos:

• list.html, que corresponde ao modelo da página que irá descrever um dos artigos (um autor, para nós, e todos os artigos a ele ligados)
• terms.html, que corresponde à página que listará todos os itens de uma taxonomia (todos os autores, portanto)

No nosso caso, vamos criar uma taxonomia de autor. Serão pós-autores, e não autores de livros, como no exemplo da ligação anterior.

Trabalharemos em duas árvores:

• a pasta content, logicamente na raiz do site hugo ;
• a pasta layout do tema utilizado pelo sítio.

Os dados relativos aos itens da taxonomia​

Na pasta content, criaremos uma pasta para cada autor, na qual será colocado um ficheiro _index.md,

content
└── authors/
    ├── j0rdan-m/
    │   └── _index.md
    └── author-2/
        └── _index.md

Cada _index.md descreve um autor, e é composto da seguinte forma:

---
name: j0rdan-m
photo: 'https://j0rdan-m.gitlab.io/blog/pearlbonnet.png'
twitter: '@j0rdan_m'
---
j0rdan é um autor do blog

Metadados​

Os dados relativos aos autores estão prontos, precisamos agora de estabelecer os meta-dados.

Para tal, teremos de criar uma pasta outide no layout do nosso tema (e não a pasta de taxonomias, o que pode ser surpreendente).

my_theme/
└── layout/
    └── authors/
        └── list.html
        └── terms.html

O ficheiro list.html não lista os autores, mas os artigos que mencionam os autores (ou qualquer outra escolha de taxonomia).

Assim, aqui estão os conteúdos básicos do ficheiro list.hml:

<h1>{{ .Params.name }}</h1>
<img src="{{ .Params.photo }}" alt=""/>

<h2>Bio</h2>
{{ .Content }}
{{ with .Params.twitter }}
  <p>
    <a href="https://twitter.com/{{ substr . 1 }}">
      Follow {{ $.Params.name }} on Twitter
    </a>
  </p>
{{ end }}

<h2>Articles</h2>
<ul>
{{ range .Data.Pages }}
    <li><a href="{{ .Permalink }}">{{ .Title }}</a></li>
{{ end }}
</ul>

O ficheiro terms.html é o modelo da página que listará todos os autores, e proporá uma ligação para cada um deles:

<h1>Authors</h1>
<ul>
{{ range .Data.Pages }}
  <li><a href="{{ .Permalink }}">{{ .Params.name }}</a></li>
{{ end }}
</ul>

Atenção, será necessário integrar a montante e a jusante dos códigos propostos o conteúdo do tema, tomando o exemplo na página predefinida (provavelmente em temas/meu_tema/layouts/_default/single.html)

O tema utilizado por este blog ofereceu um comentário agradável para isolar a informação do tema do conteúdo (graças ao <section></section>. Outro tema que uso menciona <main></main>)

Uma vez que estamos nesta página single.html, poderemos acrescentar uma menção do autor:

{{- range .Params.authors }}
  {{- with $.Site.GetPage "taxonomyTerm" (printf "authors/%s" (urlize .)) }}
    <figure>
      <img src="{{ .Params.photo }}" alt=""/>
      <figcaption>
        <a href="{{ .Permalink }}">{{ .Params.name }}</a>
      </figcaption>
    </figure>
  {{ end }}
{{ end }}

Ce esta menção deve ser acrescentada no local da página onde se pretende que apareça, obviamente.

Finalmente, agora que tudo está pronto, podemos declarar a taxonomia no nosso ficheiro config.toml, acrescentando a seguinte nota:

[taxonomies]
  author = "authors"
  tag = "tags"
  category = "categories"

Para os meus próprios fins, adicionei manualmente uma entrada no menu, sabendo que o endereço para visualizar a sua taxonomia será :http://[mon site]/authors/

É assim que, graças às taxonomias, este blog se tornou um blog multi-autor.

Antes de começarmos, Plugins!​

Instalação​

Windows​

Assim, para pôr em acção alguns plugins no nosso ficheiro Vagrant, precisamos de os instalar directamente no nosso terminal.

Para o fazer, abrir um Powershell e instalar os seguintes plugins (note que este plugin é para o SO Windows):

vagrant plugin install vagrant-reload

Isto permitir-nos-á recarregar o nosso vm durante a criação do vm.

Outros OS​

Agora, queremos utilizar funcionalidades do windows mas estamos a utilizar um Linux ou MacOS.

Para isso, precisamos de instalar os seguintes plugins na nossa máquina Linux ou MacOS:

vagrant plugin install vagrant-reload
vagrant plugin install winrm
vagrant plugin install winrm-fs
vagrant plugin install winrm-elevated

Isto permitir-nos-á recarregar o nosso vm e utilizar características de janelas com vagabundos;

Agora que já temos os nossos plugins instalados, vamos continuar;

WSL​

O que é a WSL e o que ela faz? WSL significa Subsistema Windows para Linux e, ao instalá-lo no nosso Windows Server, permitir-nos-á, basicamente, ter Linux num terminal Windows.

Isto significa que pode, por exemplo, instalar uma ferramenta no seu Windows vm usando comandos Linux como wsl sudo apt ansible -y* (este comando irá instalar Ansible na sua máquina virtual Windows).

Mas para usar WSL precisamos de o instalar! E para o instalar vamos usar o Vagrant. Vamos dar uma vista de olhos ao nosso ficheiro Vagrant:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))

  SHELL

end

Se este ficheiro vagabundo parece familiar, deveria! Este é o ficheiro vagabundo do nosso posto anterior onde definimos a configuração da nossa máquina e instalamos Chocolatey.

Agora o que queremos fazer é instalar WSL e para o fazer precisamos de adicionar o comando de instalação no nosso fornecedor de Shell.

Por isso, copie colar isto para o terminal shell no seu vagranfile:

Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

Portanto, o nosso ficheiro vagabundo deve ter este aspecto por agora:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

end

Portanto, temos agora a WSL instalada no nosso Windows Server vm! Isto é óptimo e agora temos a liberdade de o utilizar à vontade!

Desde que instalámos Chocoaltey e WSL, queremos ter a certeza de que a máquina tem em conta as modificações aplicadas.

Para isso, utilizaremos um provisionador (shell) de recarga:

  config.vm.provision :reload

Acrescentaremos isto depois do nosso fornecedor de conchas, tal como este:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

  # trigger reload
  config.vm.provision :reload

end

Agora que o nosso provisionador é recarregado, podemos instalar o Kali Linux (base de distribuição Linux em Debian).

Para isso, vamos abrir outro termninal e usar chocolate para o instalar.

Logo após a instalação do kali linux, vamos recarregar o nosso provisionador mais uma vez.

Isto dar-nos-á a certeza de que tudo foi reiniciado, incluindo a própria máquina virtual!

Portanto, vamos ver o que precisamos de acrescentar:

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    choco install wsl-kalilinux -y
  SHELL

  # trigger reload
  config.vm.provision :reload

E agora que tudo está fresco e limpo, vamos abrir outro terminal de concha e começar a usar a WSL!

Para começar a usar a WSL e ver se funciona, vamos adicionar uma concha com uma simples actualização do pacote:

wsl sudo apt update

Bastante fácil, certo? Então, vejamos como podemos utilizá-lo eficazmente.

Para o experimentar, vamos instalar algumas ferramentas que vamos precisar.

Assim, vamos instalar o Ansible e descompactar o pacote:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

  # trigger reload
  config.vm.provision :reload

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    wsl sudo apt update
    wsl sudo apt install -y ansible
    wsl sudo apt install -y unzip
  SHELL
end

Porque é que precisamos de instalar o Ansible and Unzip, pode perguntar? Bem, precisamos de descomprimir alguns ficheiros, por isso é que precisamos de descomprimir.

Para o Ansible é necessário um pouco mais de explicação, venha comigo :)

Possível​

Ansible é um motor de automação, que funciona com ficheiros .yml chamados playbooks, que automatiza o aprovisionamento de nuvens, gestão de configuração, implementação de aplicações, orquestração intra-serviço, e muitas outras necessidades de TI.

Não utiliza agentes e nenhuma infra-estrutura de segurança adicional personalizada, pelo que é fácil de implementar - e o mais importante, utiliza uma linguagem muito simples (YAML, sob a forma de Ansible Playbooks) que lhe permite descrever os seus trabalhos de automação de uma forma que se aproxima do inglês simples.

Temos também um ficheiro de hosts* (também conhecido como Inventory). É aí que vamos adicionar as nossas máquinas alvo que desejamos para executar os livros de jogo.

Consulte a ligação para uma informação mais profunda e detalhada sobre Ansible e o que faz

Portanto, para usar o Ansible precisamos de um livro de jogo funcional, anfitriões e um monte de outras coisas! E para isso vamos usar wget* para donwload um ficheiro zip contendo tudo isto (o nosso pacote unzip virá a calhar :D )

Basta copiar colar isto ao seu provisionador:

    wsl wget https://github.com/j0rdan-m/vagrant_wsl_ansible/archive/master.zip

Isto irá descarregar o ficheiro zip.

Mas precisamos de o descomprimir, por isso:

    wsl unzip master.zip

Graças a este trabalho, temos agora à nossa disposição livros de exercícios práticos.

Mas antes de os verificarmos, vamos configurar o nosso ficheiro de hosts*. Vamos apenas adicionar a máquina localhost ao ficheiro anfitrião com um utilizador, palavra-passe, método de ligação e configuração de porta.

Se tudo estiver correcto, isto deve funcionar perfeitamente com os seus livros de jogo

    wsl sudo bash -c "echo [self] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo 127.0.0.1 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo [self:vars] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_port=5985 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_connection=winrm >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_winrm_transport=basic >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_user=vagrant >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_password=vagrant >> /etc/ansible/hosts"

E, só para ter a certeza de que tudo está correcto, vamos pingar o nosso vm:

    wsl ansible self -m win_ping

Agora que o ficheiro do anfitrião está correcto, podemos avançar para os nossos livros de jogos!

Temos 3 para ser exatos! Um para instalar IIS, outro para instalar algumas ferramentas (Git, VSCode e SumatraPDF) e o último que cria um utilizador de serviço e lhe dá os direitos às pastas correctas.

Para as utilizar, precisamos de utilizar comando um livro de jogo possível, tal como este:

    wsl ansible-playbook vagrant_wsl_ansible-master/tools.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/iis.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/users.yml

Isto lançará cada livro de jogo na ordem apresentada.

Por isso, o nosso livro de jogo deve ter o seguinte aspecto:

# -*- mode: ruby -*-
# vi: set ft=ruby :

Vagrant.configure("2") do |config|

  config.vm.box = "mcree/win2019"
  config.vm.box_version = "1.0.1584095692"

  config.vm.provider "virtualbox" do |v|
    v.name = "Windows Server 2019"
    v.memory = "2048"
  end

  config.vm.provision "shell", inline: <<-SHELL

    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
    Enable-WindowsOptionalFeature -FeatureName Microsoft-Windows-Subsystem-Linux -Online -NoRestart -WarningAction SilentlyContinue

  SHELL

  # trigger reload
  config.vm.provision :reload

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    choco install wsl-kalilinux -y
  SHELL

  # trigger reload
  config.vm.provision :reload

  # execute code after reload
  config.vm.provision "shell", inline: <<-SHELL
    wsl sudo apt update
    wsl sudo apt install -y ansible
    wsl sudo apt install -y unzip
    wsl wget https://github.com/j0rdan-m/vagrant_wsl_ansible/archive/master.zip
    wsl unzip master.zip
    wsl sudo bash -c "echo [self] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo 127.0.0.1 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo [self:vars] >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_port=5985 >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_connection=winrm >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_winrm_transport=basic >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_user=vagrant >> /etc/ansible/hosts"
    wsl sudo bash -c "echo ansible_password=vagrant >> /etc/ansible/hosts"
    wsl ansible self -m win_ping
    wsl ansible-playbook vagrant_wsl_ansible-master/tools.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/iis.yml
    wsl ansible-playbook vagrant_wsl_ansible-master/users.yml

  SHELL

end

Temos agora uma máquina virtual Windows Server totalmente funcional com Ansible e um monte de outras coisas fixes nela!

Espero que isto tenha sido útil e certifique-se de verificar os outros posts ;)

Eis como escrevo artigos técnicos, para o tornar legível, e útil para o futuro, eu próprio que quero lembrar-me de como usar esse material técnico sobre o qual escrevi um artigo há vários meses.

O que está a ler é a introdução. Começo pela introdução, porque o meu tema toma esse texto como resumo na primeira página.

Aqui está o meu ficheiro post.md começando :

*my archetype*
--

Hoje quero falar sobre os arquétipos do motor de geração do sítio Hugo. Este motor muito potente é utilizado para gerar estas páginas.

<!--truncate-->

Algum tema compreende o "mais balise", pelo que a minha introdução termina com ele.

Posso terminar a minha introdução depois da <!--truncate--> se eu achar que é demasiado longo, ou outra coisa qualquer.

Títulos​

Continuo o post usando o título. Penso que o título é importante, porque nos permite compreender a estrutura do artigo, e permite aos "utilizadores de poder" ir directamente para a parte que eles excepto para encontrar informações.

No meu artigo anterior, sobre arquétipos, os meus títulos eram :

## archetypes/Default.md

(...)

## archetypes/mon_mien.md

(...)

Poderia ter usado uma estrutura mais complexa, utilizando títulos de segundo ou terceiro nível

# First level

## Second level

### Third level

Esse código será exibido assim no blogue :

Primeiro nível​

blablabla

Segundo nível​

blablabla explicado

Terceiro nível​

blablabla mais especificado

É importante colocar Título no seu tutos. Por vezes, os leitores liam mais do que um tuto ao mesmo tempo, e é mais fácil ir para a parte seguinte quando o título organizava a página.

Exibição do código​

Há dois tipos de forma de colocar o código no markdown :

código em linha​

Isto é quando se usa ``` 'my code is cool' ``` na mesma linha que o resto do texto

código de linha única isolado​

Isto é quando se utiliza :

```
my code is cool
```

O código é isolado do resto do parágrafo

O meu conselho​

Utilizar sempre o segundo. Por uma razão simples : as pessoas utilizam copiar/colar. E é tão mais fácil copiar colar uma única linha.

Próximas dicas​

Balas​

• Não
• utilização
• bala
• em todo o lado

Faça-o quando for útill. Há dois casos :

• lista de coisas
• lista de coisas

Usar citação para citação​

Usar citação para citação. Sei que parece estranho, mas poderia querer usar o bom formato de citação para outra coisa. Não o faça.

Estilo de citação é para citação - Dr. CssProvider

Os arquétipos são os elementos que geram os cabeçalhos das páginas Hugo, quando criados com o comando hugo new my_file.md.

archetypes/Default.md​

O 'default.md' no arquétipo aplica-se a qualquer 'novo hugo' que criar. Este 'default.md' é personalizável, como se viu no artigo anterior, Gerir conteúdo num sítio Hugo, mas também pode ser multiplicado.

archetypes/custom.md​

Imaginemos o caso de um sítio ESN (ao acaso ;) ), no qual encontraremos uma página inicial, um certo número de páginas 'Produtos', páginas 'Ofertas' e uma página 'blogue'.

Será suficiente criar, na pasta arquivos, três ficheiros :

• produto.md
• oferta.md
• post.md

Estes três ficheiros conterão os arquétipos apropriados para o tipo de página.

É muito simples aplicar um arquétipo a uma página: o arquétipo deve ter o mesmo nome que o directório que hospeda o tipo de página!

Por exemplo, para criar uma página de produto, uma página de oferta e um post de blogue, utilizaremos estes três comandos:

# Nouvelle page produit
hugo new produit/eaviz.md

# Nouvelle offre Marte
hugo new offre/expert_ansible.md

# Nouvel article de blog
hugo new post/gestion_archetype.md

Gestão temática​

Tal como o config.toml da secção exampleSite de um tema, aconselho-o vivamente a partir do(s) arquétipo(s) proposto(s) por um tema. Isto permitir-lhe-á conhecer os directórios de trabalho correctos para ver as suas páginas aparecerem nos locais fornecidos pelo tema.

O objectivo deste posto é esclarecer como proceder para facilitar a criação do posto.

*Declaração de responsabilidade: o tutorial oficial é ** muito mau** no caso de um site que se queira colocar sob gitlab Pages!

Gestão de páginas​

No contexto de um site em modo blogue, isto é relativamente simples.

O comando ``hugo new directory/postname.md``` permite adicionar mensagens em formato MD à pasta "directório". Normalmente, o "post" é utilizado para um blogue.

Propriedades da página​

As propriedades de uma página são geridas no cabeçalho das páginas criadas. Podem ser encontradas na seguinte forma:

---
title: "mon artigo"
date: AAAA/MM/DD/THH:MM:SS
draft: true

Este é o padrão gerado por Hugo. Dois elementos devem ser assinalados:

1. Numa implantação de gitlab, apenas páginas de "rascunho: falso" são exibidas. As páginas de "rascunho: verdadeiro" são ignoradas na construção do sítio. É então possível construir um sítio localmente (com a opção -D para draft) e testar algumas páginas enquanto se tira partido do alojamento do gitlab.
2. A versão básica pode ser completada com outras informações sobre a página criada:

• subtítulo: para adicionar um subtítulo
• etiquetas: para adicionar etiquetas a um artigo
• categorias: para categorizar artigos

Em suma, nada de louco, mas é útil. Portanto, o cabeçalho do artigo que está a ler é :

---
title: "Gérer du contenu dans un site Hugo"
date: 2020-04-14T09:39:30Z
draft: false
subtitle: "Comment gérer du contenu dans un site statique généré par Hugo"
tags:
- français
- hugo-tips
categories:
- hugo
---

Gestão de imagens​

Para gerir as imagens apresentadas num artigo, eis a solução que proponho, que tem a vantagem de trabalhar com hugo localmente, mas também com uma implantação de gitlab:

1. Criar uma subpasta "imagens" no directório "conteúdo
2. Coloque aí as imagens que pretende que apareçam no seu artigo
3. acrescentar ![texte alternatif](../../images/mon_image.jpg) no seu artigo, onde deseja que a imagem apareça.

Gerir conteúdos relacionados com temas (fotos de fundo, avatares, etc.)​

Nestes casos, a gestão de imagens locais pode ser complicada de gerir se se quiser que a operação seja idêntica quer se utilize o motor hugo localmente ou na versão Gitlab Pages.

É por isso que proponho a sua gestão da seguinte forma:

Criar um directório chamado "estático" na raiz do seu site. Coloque as imagens que pretende utilizar directamente neste directório, sem as colocar num subdirectório. Elas serão então utilizáveis no seu ficheiro config.toml, bastando para tal dar o seu nome.