Mostrando postagens com marcador Linux. Mostrar todas as postagens
Mostrando postagens com marcador Linux. Mostrar todas as postagens

terça-feira, 14 de março de 2023

Alterando encoding de arquivos no Linux

 As vezes precisamos mudar o Encoding de um arquivo para corrigir os caracteres estranhos.


Para descobrir a codificação de origem pode-se usar a ferramenta file, exemplo:


$ file [nome_arquivo]


Exemplo de conversão de ISO-8859-1 para UTF-8:


$ iconv -f iso-8859-1 -t utf-8 arquivo.txt > arquivo_novo.txt


Uma dica importante é criar um novo arquivo pra saída, pois assim você não perde seus dados... (ele apaga mesmo!) Crie um novo arquivo, verifique se está tudo certo e somente depois sobrescreva o arquivo original.

segunda-feira, 13 de março de 2023

Alternando entre versões do Java no Linux

        Nesse artigo vou mostrar como mudar da versão do Java em um servidor Linux. Essa mudança altera a versão padrão em uso pelo servidor, embora aplicações possam apontar diretamente para uma versão ao invés de usar a versão padrão definida para o servidor.


$ sudo update-alternatives --config java


       Irá aparecer a lista de versões disponíveis e você pode digitar o número correspondente a versão desejada e depois confirmar com Enter.




       Este comando também é útil para ver onde as versões foram instaladas no servidor, porque ele mostra o caminho completo. Importante lembrar que algumas versões que possam ter sido baixadas e descompactadas não irão aparecer.




segunda-feira, 6 de março de 2023

Particionando, Formatando e Montando discos no Linux

 

Nesse artigo vamos mostrar como montar um disco no Linux. Ao adicionar um novo disco, físico ou lógico dependendo do ambiente, é necessário adicioná-lo ao sistema. Esse processo é chamado de montagem.

 

Para vermos os discos disponíveis podemos usar o comando lsblk:

 

$ sudo lsblk

 

Antes de montar é necessário particionar e formatar o disco. Os discos seguem uma ordem alfabética: sda (principal), sdb (segundo), sdc (terceiro)... e assim por diante. Vamos seguir como se fosse o segundo disco. Primeiro vamos particionar:

 

$ fdisk /dev/sdb

 

Então o fdisk vai pedir algumas opções para poder particionar o disco e oferecer a opção “m” para ajuda. Para particionar como uma única partição primária de dados você pode fornecer a opção “n” e depois escolher “p” para a primária. Depois siga o prompt confirmando o número de partições (que é 1) e o início e fim dela. Após receber a mensagem que a partição foi criada, digite “w” para confirmar as alterações no disco.

 

Para formatar digite:

 

$ mkfs.ext4 /dev/sdb

 

Caso queira uma partição onde o Windows possa enxergar também use NTFS.

 

Agora vamos à montagem do disco para uso. As montagens podem ser feitas em qualquer pasta do sistema, porém existe um diretório padrão para isso que o /mnt.

 

Vamos imaginar que vamos montá-lo na pasta chamada “arquivos”. Primeiro criamos a pasta:

 

$ mkdir /mnt/arquivos

  

Agora fazemos a montagem apontando o disco para a pasta:

 

$ mount /dev/sdb /mnt/arquivos

 

Dessa maneira o disco está montado e disponível, a menos que o sistema seja reiniciado. Para manter o disco montado sempre que o sistema ligar ainda é necessário automatizar essa montagem. Abra o arquivo fstab que fica no etc e acrescente a seguinte linha informando o disco, pra onde vai e o sistema de arquivos, além do padrão “defaults 0 0”:

 

$ /dev/sdb /mnt/arquivos ext4 defaults 0 0

 

Agora é só salvar o arquivo e ele sempre será montado ao iniciar o sistema.




sábado, 4 de fevereiro de 2023

Instalando o Docker no Windows usando WSL 2 e Ubuntu

          Nesse artigo vamos configurar o Docker pra rodar no Ubuntu através do WSL 2 de forma nativa (como se a máquina fosse Linux puro). Caso não tenha o WSL 2 configurado veja aqui como fazer: Configuração WSL 2

 

Agora vamos ao Docker! O primeiro passo é atualizar a biblioteca do Ubuntu de gerenciamento de programas:

 Obs: Para versão 22-4 do Ubuntu ver aqui. 


$ sudo apt update && sudo apt upgrade

 

Depois instalar as dependências como Http, certificados, acesso a URLs, etc...

 

$ sudo apt-get install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg \
    lsb-release

 

Agora adicionar o repositório Docker na biblioteca do Ubuntu:

 

$ sudo mkdir -p /etc/apt/keyrings

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

 

Agora para configurar o repositório:

 

$ echo \

  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

 

Vamos mais uma vez atualizar a biblioteca:

 

$ sudo apt-get update

 

Agora sim vamos instalar o Docker. Para a instalar a última versão usamos:

 

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

 

Para instalar uma versão específica primeiro listamos as versões:

 

$ apt-cache madison docker-ce | awk '{ print $3 }'

 

E então instalamos a que desejamos. Ex:

 

$ VERSION_STRING=5:20.10.13~3-0~ubuntu-jammy

$ sudo apt-get install docker-ce=$VERSION_STRING docker-ce-cli=$VERSION_STRING containerd.io docker-compose-plugin

 

É preciso também dar permissão a pasta criada. A instalação do Docker já espera que haja um grupo chamado "docker". Veja com o comando "groups" se esse grupo "docker" já existe, caso não tenha sido criado, siga as duas linhas abaixo, caso tenha sido criado, apenas adicione seu usuário a ele.

 

$ sudo groupadd Docker

$ sudo usermod -aG docker $USER

 

Pronto, agora é só fazer logoff e login ou fechar o app do Ubuntu e abrir novamente para poder usar o docker.

 

Atenção! Em alguns casos ao sair e entrar no App do Ubuntu (e outras distribuições) ele desliga o serviço do Docker. Caso isso aconteça pode ser resolvido da seguinte maneira:

 

$ sudo systemctl enable docker.service

$ sudo systemctl enable containerd.service

 

Isso adiciona o serviço do Docker ao Systemd que gerencia serviços que inicializam automaticamente. Caso queira remover basta usar o "disable" ao invés do "enable".

 

 

Fonte:

https://docs.docker.com/engine/install/ubuntu/

https://docs.docker.com/engine/install/linux-postinstall/

https://github.com/codeedu/wsl2-docker-quickstart#instala%C3%A7%C3%A3o-do-wsl-2

 

Configurando o WSL 2 no Windows 10 - (Linux no Windows)

           Nesse artigo vou mostrar como configurar o WSL 2 no Windows para podermos usar uma distribuição Linux como se estivéssemos rodando ela direto sobre o hardware sem o Windows.

 

Abra o PowerShell em modo administrador e execute os comandos para habilitar o WSL 2:

 

> dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

 

> dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

 

Teste o comando wsl, se não funcionar é preciso reiniciar o computador. Funcionando, baixe e instale o kernel do WSL no endereço:  https://docs.microsoft.com/pt-br/windows/wsl/wsl2-kernel 

 

Agora mude a versão do WSL para a 2:

 

> wsl --set-default-version 2

  

Pronto, agora na Windows Store você escolhe a distribuição que você quer e clica em instalar. Geralmente a mais usada é o Ubuntu, mas fica a seu critério. No processo de instalação ou primeiro acesso vai ser pedido para você fornecer um nome de usuário e senha para o S.O do Linux. Você pode fornecer os mesmos que usa no Windows ou outro.

 

 

Fonte:

https://learn.microsoft.com/pt-br/windows/wsl/

https://github.com/codeedu/wsl2-docker-quickstart#instala%C3%A7%C3%A3o-do-wsl-2

 

quinta-feira, 16 de junho de 2022

Visualizando processos Java rodando em um ambiente Linux com os comandos TOP e PS

Nesse artigo eu vou mostrar duas formas de exibir os processos Java que estão rodando em uma máquina Linux. Isso é muito importante pra ver de forma rápida quantidade de uso de memória, quantidade de intâncias de aplicações rodando, parâmetros passado para JVM, tempo de atividade de cada processo, etc.

 

A primeira é mais resumida, onde as principais informações que vamos ter são: número do processo, usuário responsável, tempo de execução e memória em uso. Para isto basta executar o comando:

 

$ top -bc -n 1 |grep java

 

A segunda é mais longa pois além das informações da primeira, ela também mostra os argumentos passados para a JVM, o que pode ser muito útil quando precisamos ver se alguma configuração feita realmente está sendo utilizada.

 

$ ps aux | grep -i java


        Para esse artigo é só, espero que ajude no dia a dia das atividades de monitoramento e manutenção das aplicações.

quarta-feira, 4 de maio de 2022

Criando um link simbólico para um diretório no Linux

          Nesse artigo vou mostrar como links simbólicos no Linux. Links simbólicos servem para apontarmos para um diretório ou arquivo de outro lugar. Para isso usamos o comando ln:

 

$ ln -sf /diretorioOrigem /diretorioLink

 

No parâmetro “-sf” o s é para especificar que vai ser um link simbólico e o f é pra forçar a criação caso o destino já seja um link simbólico. 

terça-feira, 3 de maio de 2022

Mudando usuário e grupo de um arquivo no Linux (chown e chgrp)

         Nesse artigo vou mostrar como mudar o proprietário de pastas e arquivos no Linux. Vamos imaginar que temos a pasta /home/usuario/meus_arquivos e queremos atribuir a um usuário e grupo específicos estes arquivos arquivos:

 

Para isso usamos o comando chown:

 

chown -R nomeUsuario:nomeGrupo /home/usuario/meus_arquivos/

 

O parâmetro “-R” é para aplicar de modo recursivo, assim ele vai alterar as pastas, subpastas e arquivos que existirem na pasta definida. Logo em seguida vem o nome do usuario e nome do grupo que serão atribuídos como donos e são separados por ":" (dois pontos)  e depois a pasta a ter o dono alterado. Não é necessário informar o grupo caso queira mudar só o usuário, e se quiser mudar só o grupo use o chgrp.


Isso é bastante usado no Linux pois determina quem pode fazer determinadas coisas com os arquivos sem ter que dar permissões para todo mundo.

quinta-feira, 31 de março de 2022

Compactando arquivos no linux

            Nesse artigo vou mostrar como compactar e descompactar arquivos e diretórios no Linux. Vamos imaginar que temos a pasta /home/usuario/meus_arquivos e queremos compactar seus arquivos:

 

Para compactar, usamos:

 

$ zip -r nomeArquivoZip.zip /home/usuario/meus_arquivos/

 

O parâmetro “-r” é de recursivo, assim ele vai incluir as pastas, subpastas e arquivos que existirem na pasta definida. Logo em seguida vem o nome do arquivo zip que será criado, e depois a pasta a ser compactada.

 

Para zipar apenas alguns arquivos, podemos separar os arquivos por espaço.

 

Agora para descompactar usamos o unzip:

 

$ unzip nomeArquivoZip.zip

 

             Para ver o conteúdo sem descompactar podemos passar o parâmetro -l.

quinta-feira, 10 de junho de 2021

Estrutura de diretórios Linux

      Nesse post trago apenas uma imagem que a Vannessa Moura postou no linkedin e mostra a estrutura de diretórios no Linux. Deixei aqui pra garantir ter sempre a mão quando precisar.




sexta-feira, 27 de março de 2020

Multiplas SSHs Key para Repositórios Git

As vezes precisamos de mais de uma chave SSH para podermos acessar repositórios Git com usuários diferentes, como por exemplo seu usuário pessoal e o usuário do trabalho. 

       Se os projetos estiverem no mesmo repositório a configuração é um pouco diferente; se forem em locais difetentes: GitHub, GitLab, BitBucket, etc,  é mais simples.

       Vamos começar. A primeira parte é igual, não importa se os projetos estão em um mesmo repositório ou não, que é a geração da chave.

Estamos assumindo que você já possui uma chave configurada para um usuário e quer criar a segunda chave SSH. Então, vamos começar executando o git-bash, um terminal Linux para o Windows que também faz parte da instalação do Git. Após aberto o git-bash, digite:

ssh-keygen -t rsa -b 4096 -C "seu-email-outro-usuario@aqui.com"

Você será indagado sobre onde salvar a chave, sendo que não podemos criar a chave SSH no caminho e nome default, pois já existe uma chave SSH lá. Mude o caminho ou o nome do arquivo, por exemplo, acrescentando .ssh/id_rsa_trabalho no final do nome da chave. Continue a geração, entrando com a senha e confirmando:

Enter passphrase (empty for no passphrase):
Enter same passphrase again:

Caso não queira informar uma senha, pode apenas confirmar sem digitar nada (é recomendado criar uma senha, claro!). Então o prompt lhe informa que a sua chave privada e a sua chave publica estão no caminho indicado previamente, que se for o default é: C:\Users\seu-usuario\.ssh.

Copie e adicione sua chave pública à sua conta no repositório, o comando abaixo copia sua chave para a memória e deixa pronto para colar no lá:

clip < ~/.ssh/id_rsa_trabalho.pub

Nesse momento temos a nossa segunda chave SSH, precisamos configurar quando usar cada uma. Para isso, dentro do diretório do C:\Users\seu-usuario\.ssh que é onde ficam as chaves por padrão, crie um arquivo chamado config. Nesse arquivo vamos configurar o acesso a cada repositório por uma chave.

      Segue o exemplo de um arquivo para acessar o GitHub e o Bitbucket com usuários diferentes, e o bitbucket sendo acessado através da nossa nova chave:

Host bitbucket.org
    HostName bitbucket.org
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_trabalho

Host github.com
    HostName github.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa


Pronto! Se você queria acessar projetos em repositórios diferentes com chaves diferentes sua máquina já está configurada, basta clonar normalmente seus projetos.

     Agora se você quer acessar com duas chaves no mesmo repositório, precisamos do pulo do gato. Já viu que quando vai clonar um projeto seu a URL é mais ou menos assim:

git@github.com:GbDanielO/p-calendar-ptbr.git

      Veja que vem o nome do repositório, como no destaque, depois o nome do projeto. Vamos usar isso pra diferenciar qual chave usar, mas ao invés de separar por ":" vamos separar por "traço". Vamos imaginar que a nossa url fosse: git@github.com:trabalho/p-calendar-ptbr.git. Você precisa fazer dessa forma:


Host github.com-trabalho
    HostName github.com
    PreferredAuthentications publickey
    IdentityFile ~/.ssh/id_rsa_trabalho

Host github.com
    HostName github.com
    PreferredAuthentications publickey

    IdentityFile ~/.ssh/id_rsa

       Note que o HostName é igual para as duas configurações, o que muda é o Host, que identifica qual chave usar. ATENÇÃO! Agora com essa mudança, sua forma de fazer o clone do projeto no repositório trabalho mudou. O outro acesso continua como antes.

       Ficará dessa forma:

git clone git@github.com-trabalho:trabalho/p-calendar-ptbr.git

       Pronto, no demais é tudo igual.




Fonte:
https://superuser.com/questions/366649/ssh-config-same-host-but-different-keys-and-usernames
https://backefront.com.br/diferentes-sshkey-mesmo-computador/
https://victortorres.net.br/2018/12/03/mais-de-uma-chave-ssh-no-git 



segunda-feira, 9 de dezembro de 2019

Inicializando e parando o Tomcat no Linux com o comando "service"

    Nesse post vou mostrar como configurar o Tomcat para ser inicializado e parado através do comando "service", e como colocar o servidor de aplicação para ser startado juntamente com a máquina.

    Vamos a configuração: Crie um arquivo em /etc/init.d/ chamado tomcat (não precisa de extensão) com o seguinte conteúdo:

#config tomcat
 

export CATALINA_HOME="/opt/apache-tomcat-7.0.69"

ERROR=0

case "$1" in
  start)
    echo $"Iniciando o Tomcat"
    sh $CATALINA_HOME/bin/startup.sh
    ;;

  stop)
    echo $"Parando servidor Tomcat"
        sh $CATALINA_HOME/bin/shutdown.sh
    ;;

  restart)
    echo $"Parando servidor Tomcat"
    sh $CATALINA_HOME/bin/shutdown.sh
    echo $"Iniciando servidor Tomcat"
    sh $CATALINA_HOME/bin/startup.sh
    ;;

  *)
    echo $"Uso: $0 {start|stop|restar}"

 exit 1
 ;;

esac

exit $ERROR


    Na parte destacada em amarelo, lembrar de colocar o caminho e versão do Tomcat do seu servidor. Agora vamos dar a permisão de leitura e execução:

chmod +rx /etc/init.d/tomcat

   Pronto, agora para inicializar o Tomcat bastausar o comando:

service tomcat start 
   
   E para parar:

service tomcat stop

   O restart por sua vez executa os dois comandos. Agora vamos configurar para iniciar o script no start do servidor. Basta executar este comando:

update-rc.d tomcat defaults

   Através deste comando é criado o link simbólico para a execução na inicialização do Linux. Para remover ele basta executar o seguinte:

update-rc.d tomcat remove

   Para esse post é só! Como sempre, espero ter ajudado...
 

sábado, 2 de novembro de 2019

SED (Stream EDitor)

O SED é um editor de texto para usarmos em scripts de configuração para automatizarmos algumas tarefas.
Esse artigo não é de minha autoria e o link do conteúdo original está no final.
1 - Troca todas as palavras em um arquivo por outra

sed -i 's/palavra/outra/' arquivo.txt

2 - Imprime só a nona linha

sed -n '9p' arquivo.txt

3 - Imprime da sexta linha até a nona linha

sed -n '6,9p' arquivo.txt

4 - Deleta todas as linhas que contém a palavra desejada no arquivo

sed -i '/palavra_desejada/d' arquivo.txt

5 - Coloca uma palavra no INÍCIO de cada linha

sed 's/^/palavra/' arquivo.txt

6 - Coloca uma palavra no final de cada linha

sed 's/$/palavra/' arquivo.txt

7 - Imprime só as linhas que COMEÇAM com a string ‘http’

sed -n '/^http/p' arquivo.txt

8 - Deleta só as linhas que COMEÇAM com a string ‘http’

sed -n '/^http/d' arquivo.txt

9 - Troca TODAS ocorrências da palavra “marcos”, “eric”, “camila” pela palavra “pinguim”

sed 's/marcos\|eric\|camila/pinguim/g' arquivo.txt

10 - Troca tudo que estiver ENTRE as palavras “Marcos” e “Eric” pela palavra “eles”, exemplo, o texto é:

“No sábado Marcos saiu de pra brincar de bicicleta com o Eric, mas não ficaram até tarde.” e ficará assim: “No sábado eles, mas não ficaram até tarde.”

sed 's/Marcos.*Eric/eles/' arquivo.txt

11 - Deleta linha em branco e altera o arquivo

sed -i '/^$/d' arquivo.txt

12 - Substitui “foo” por “bar” somente as linhas que contém “plop”

sed '/plop/ s/foo/bar/g' arquivo.txt

13 - Substitui “foo” por “bar” exceto as linhas que contém “plop”

sed '/plop/! s/foo/bar/g' arquivo.txt

14 - Insere da Linha 2 a linha 7 o “#” no início de cada linha

sed '2,7s/^/#/' arquivo.txt

15 - Insere a palavra ‘NEW’ no início de cada linha, da linha 21 até a linha 28:

sed -i '21,28s/^/NEW/' arquivo.txt

16 - Troca tudo entre as tags “<” e “>” pela palavra “CODIGO”:

sed 's/<[^>]*>/CODIGO/g' arquivo.txt

17 - Imprime somente a primeira ocorrência da linha com determinada palavra:

sed -n '/dia/{p;q;}' arquivo.txt

18 - Inclue texto no final da linha 9:

sed '9s/$/final da linha/' arquivo.txt

19 - Coloca todas as linhas em uma só:

sed ':a;$!N;s/\n//;ta;' arquivo.txt

20 - Substitui a palavra “BELEZA” por “SIM” somente entre determinadas linhas:

sed '3,6s/BELEZA/SIM/' arquivo.txt

21 - Apaga o que está entre a palavra “falou” e “segundo” ( delimitadores )

sed '/segundo/{/falou/{s/segundo.*falou//;t};:a;/falou/!{N;s/\n//;ta;};s/segundo.*falou/\n/;}' arquivo.txt

22 - Retira comandos HTML (tudo entre < e > )

sed 's/<[^>]*>//g' arquivo.txt

23 - Apaga o 1° caracter da frase

sed 's/.//' arquivo.txt

24 - Apaga o 4° caractere da frase

sed 's/.//4' arquivo.txt

25 - Apaga os 4 primeiros caracteres

sed 's/.\{4\}//' arquivo.txt

26 - Apaga no mínimo 4 caracteres

sed 's/.\{4,\}//' arquivo.txt

27 - Apaga de 2 a 4 caracteres (o máx. que tiver)

sed 's/.\{2,4\}//' arquivo.txt

28 - Exemplos de intervalo

echo "aáeéiíoóuú" | sed "s/[a-u]//g"

saída: áéíóú

echo "aáeéiíoóuú" | sed "s/[á-ú]//g"

saída: aeiou

29 - Transforma texto (URL) em tags HTML de links.

Era : http://www.com

Fica: <a href=”http://www.com”>http://www.com</a>

sed 's_\<\(ht\|f\)tp://[^ ]*_<a href="&">&</a>_' arquivo.txt



O link abaixo ainda traz o uso de REGEX:

https://terminalroot.com.br/2015/07/30-exemplos-do-comando-sed-com-regex.html