Um video de como fazer um script em bash utilizando arrays:
https://www.youtube.com/watch?v=K2plzc4vJvw
Um video de como fazer um script em bash utilizando arrays:
https://www.youtube.com/watch?v=K2plzc4vJvw
git init - Initialize a new Git repository.
git clone - Clone a remote repository to your local machine.
git status - Check the current state of your working directory.
git add - Stage changes for the next commit.
git commit - Record staged changes and create a snapshot.
git push - Upload local changes to a remote repository.
git pull - Fetch and merge changes from a remote repository.
git branch - List, create, or delete branches.
git checkout / git switch - Switch between branches or commits.
git merge - Integrate changes from one branch into another.
git diff - View differences between working directory and staging area.
git log - Display a chronological list of commits.
Exemplo de configuração de rede com Netplan:
$ vim /etc/netplan/00-installer-config.yaml
network:
version: 2
renderer: networkd
ethernets:
eth0:
addresses:
- 10.0.0.1/24
routes:
- to: default
via: 10.0.0.254
nameservers:
search: [meuDomain, outroDomain]
addresses: [10.10.10.10, 10.10.10.11]
$ sudo netplan apply
Já
vos aconteceu usarem a instalação mínima e não terem ferramentas como o
VI ou o Ping?! E depois reconfigurar a rede sem estas ferramentas?!
Aqui ficam alguns comandos rápidos para desenrascar:
$ ip a add 192.168.0.10/24 dev eth0
$ echo "nameserver 8.8.8.8" > /etc/resolv.conf
$ ip route add default via 192.160.0.254
Ferramentas a instalar que podem ser necessárias:
$ apt-get install vim
$ apt-get install iputils-ping
# Instalar ifconfig, ...
$ apt-get install net-tools
# Instalar dig, Nslookup, ...
$ apt-get install bind9-utils
$ apt-get install telnet
Trago aqui um caso prático que me deparei esta semana. Aumentar um volume (VG - Volume Group) que contém 2 discos, ou seja, 2 Physical Volumes, onde um deles é uma partição e o outro é o disco inteiro:
vg-01 = /dev/sda2 (49GB) + /dev/sdb (151GB)
Podemos ver obter a informação acima com o comando pvdisplay.
Passos para incrementar o disco:
- Aumentar o disco físico nas propriedades da VM.
- No Linux, aumentar o PV.
- E de seguida aumentar o LV.
- E por fim aumentar o sistema de ficheiros.
$ pvresize /dev/sdb $ lvextend -l +100%FREE /dev/vg-01/lv-01 $ resize2fs /dev/vg-01/lv-01
Comandos para verificar os vários passos:
pvdisplay - Verificar se o PV foi aumentado.
lvdisplay - Verificar se o LV foi aumentado.
fdisk - l - Identificar antes de toda a operação os discos e partições existentes.
df -h - Verificar se o aumento de espaço se refletiu.
$ find /usr/share -name '
ficheiro.txt'
#Igual ao anterior mas com case insensitive:$ find /usr/share -name 'ficheiro.txt'
#Encontrar todos os ficheiros que iniciem por f:
$ find /usr/share -name 'f*'#Encontrar todos os ficheiros que Não iniciem por f:
$ find /usr/share -not -name 'f*'
$ find /usr/share -size +10M#Econtrar ficheiro com o tamanho exato de 512k:
$ find /usr/share -size 512k
#Ficheiros modificados no último minuto:
$ find /usr/share -mmin -1
#Ficheiros modificados nas últimmas 24h$ find /usr/share -mtime -0
#Ficheiros modificados nas últimmas 24h
$ find /usr/share -mtime -0
#Econtra pelo nome e pelo tamanho:
$ find
-name '
ficheiro.txt'
-size 10M
#Encontra pelo nome ou pelo tamanho:
$find
-name '
ficheiro.txt'
-o -size 10M
$ find -perm 664
https://www.baeldung.com/ops/kubernetes-deployment-vs-replicaset
Aqui ficam alguns comando do jornalctl que são uma alternativa à análise de logs tradicional do /var/log.
$ journalctl -e
$ journalctl -p err
$ journalctl -p warning
$ journalctl /usr/bin/sudo
$ journalctl -u sshd.service
$ journalctl -f #Fica ativo para ir mostrando os logs que estão a ser gerados
$ journalctl -S 04:00
$ journalctl -S 04:00 -U 05:00
$ journalctl -S '2022-11-11 13:05:00'
$ journalctl -b 0 #Logs desde o atual booy
$ journalctl -b -1 #Logs do boot anterior. (É preciso instruções adicionais)
$ last #Histórico de logs de quem entrou no sistema
$ lastlog
Este erro surge porque o módulo da floppy disk está instalado e algo a tentar usar, assim podemos remove-lo da seguinte forma:
sudo rmmod floppy
echo "blacklist floppy" | sudo tee /etc/modprobe.d/blacklist-floppy.conf
sudo dpkg-reconfigure initramfs-tools
Uma forma rápida e fácil de instalar uma versão específica do java:
$ sudo curl https://download.java.net/java/GA/jdk20/bdc68b4b9cbc4ebcb30745c85038d91d/36/GPL/openjdk-20_linux-x64_bin.tar.gz --output /opt/openjdk-20_linux-x64_bin.tar.gz
$ sudo tar -xf /opt/openjdk-20_linux-x64_bin.tar.gz -C /opt/
$ /opt/jdk-20/bin/java -version$ export PATH=$PATH:/opt/jdk-20/bin
Existem 3 tipos de rede por defeito no Docker: Bridge, None e Host.
Bridge - docker run ubuntu
O Docker cria esta rede privada interna por defeito no anfitrião (host, máquina virtual ou computador físico onde está a correr o Docker) e todos os containers obtêm um IP interno normalmente na gama 172.17.x.x. Os containers ligam-se uns aos outros usando esta rede interna.
Para
as redes externas se ligarem a estes containers é preciso mapear portos
de rede entre si (anfitrião:80 <-->container:8080).
None - docker run ubuntu --network=none
Os containers estão desligados de qualquer rede estando completamente isolados.
Host - docker run ubuntu --network=host
Outra forma de redes externas obterem acesso aos containers é associar o container à rede do anfitrião quebrando-se desta forma o isolamento que existe entre o anfitrião e o container. Assim, qualquer aplicação a correr no container num porto qualquer fica imediatamente exposto ao exterior no mesmo porto.
Por defeito o Docker cria uma rede interna para os containers comunicarem entre si na gama 172.17.x.x. É possível criar outra rede interna, noutra gama, com o seguinte comando:
$ docker network create --driver bridge --subnet 10.10.0.0/16 custom-isolated-network
DNS
Os containers conseguem comunicar entre si usando o seu nome que por sua vez é um nome DNS no servidor de nomes embebido no Docker.
Quando queremos que uma aplicação num container, aceda a outra noutro container, no mesmo Docker Host, podemos usar o IP interno (por exemplo: 172.17.0.3 <--> 172.17.0.8). Mas a forma mais correta é usar o nome do container, uma vez que ao reiniciar o container, este pode não assumir o mesmo IP.
O servidor DNS embebido no Docker é executado com o IP 127.0.0.11.
Deixo aqui alguns dos comandos (básico) mais usados no Docker:
$ docker ps
$ docker ps -a
$ docker rm CONTAINER
$ docker rmi IMAGEM
$ docker run ubuntu
# -it disponibiliza uma shell interativa
$ docker run -it ubuntu
$ docker run -it ubuntu bash
$ docker run -d centos sleep 500
$ docker images
$ docker pull nginx
$ docker run -d ubuntu sleep 500
$ docker exec CONTAINER_ID cat /etc/*release*
$ docker stop $(docker ps -aq)
$ docker rm $(docker ps -aq)
$ docker run -i CONTAINER
# -p mapeia o porto 80 do anfitrião para o 5050 do container nginx
$ docker run -p 80:5050 nginx
$ docker run -p 3306:3306 mysql
# Executa o container mysql mapeando a dir /var/lib/mysql na dir /dados/mysql do anfitrião(host), de forma a persistir os dados:
$ docker run -v /dados/mysql:/var/lib/mysql mysql
# Obter informações do container no formato json:
$ docker inspect CONTAINER
$ docker logs CONTAINER
# Criar o dir .ssh directory, e aplicar permissões:
mkdir ~joselito/.ssh
chown joselito ~joselito/.ssh
chmod 0700 ~joselito/.ssh
# Criar o ficheiro authorized_keys e aplicar permissões:
touch ~joselito/.ssh/authorized_keys
chown joselito ~joselitos/.ssh/authorized_keys
chmod 0600 ~joselito/.ssh/authorized_keys
Codificar:
$ echo -n "Palavra_a_codificar" | base64
UGFsYXZyYV9hX2NvZGlmaWNhcg==
Descodificar:
$
echo -n "UGFsYXZyYV9hX2NvZGlmaWNhcg==" | base64 --decode
Palavra_a_codificar
Instalação da ferramenta de monitorização de recursos Metrics Server:
$
git clone https://github.com/kodekloudhub/kubernetes-metrics-server.git
$ kubectl create -f kubernetes-metrics-server/
Exemplos:
$ kubectl top node
$ kubectl top pod