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]
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
Em Kubernetes existem 3 tipos de objetos que é preciso conhecer bem:
Pod:
Deployment:
Service:
Não duvidem que a grande maioria das aplicações que acedemos via internet está assente em Kubernetes.
No seguimento do estudo que tenho vindo a fazer, deixo mais abaixo uma lista dos comandos mais usados e a sua função.
Nota:Esta lista estará em constante atualização.
Comandos relativos à criação do cluster com o Minikube:
$ minikube start#Cria um cluster com 1 nó.
$ minikube start --nodes 2 -p multinode-cluster$ minikube status$ minikube ip$ minikube ssh$ minikube dashboard #Dashboard web que mostra alguns dados.$ minikube logs$ minikube delete #Remove o cluster.$ minikube delete --purge #Remove o cluster e todos os ficheiros associados.$ minikube tunnel - Cria uma rota de rede para o IP do cluster como se fosse um gateway. Para testar por exemplo um serviço a correr em LB.
https://minikube.sigs.k8s.io/docs/
Comandos relativos à criação do cluster com o Kind:
$ kind create cluster$ kind create cluster --name NomeDoCluster$ kind get clusters #Visualisar os cluster.$ kind delete clusters $(kind get clusters) #Elimina todos os cluster.$ kind create cluster --name kind-3Nos --config 3Nos.yaml #Cria um cluster baseado no ficheiro yaml.
kubectl:
### Get informação
$ kubectl get pods
$kubectl get namespaces #Ver os vários NS existentes.$kubectl get namespaces$kubectl get pod -n Development #Ver os pods do NS Development.$ kubectl get pods -A #Ver todos$ kubectl get pods -A -o wide #Devolve mais informação como o IP, etc.$ kubectl get pods NOME_DO_POD -o yaml/json # ver dados do pod em yaml/json.
$ kubectl cluster-info
$ kubectl get nodes
$ kubectl get pod meuPod -o jsonpath='{.spec.containers[*].name}' #Devolve o nome dos containers que estão no Pod meuPod.
$ kubectl describe pod meuPod #Toda a informação sobre o Pod, numero de containers, estado, etc.
$ kubectl replace --force -f meuPod.yaml #Elimina e cria um novo pod.
### Logs
$ kubectl logs meuPod
$ kubectl logs meuPod -c meuContainer
### Criar um pod básico
$kubectl run meuNginx --image nginx #Cria um pod com um container a partir da imagem nginx.$kubectl delete pod meuNginx
### Criar pods a partir de um manifesto yaml$ kubectl apply -f podTemplate.yaml #Cria um pod a partir do manifesto yaml.$ kubectl delete -f podTemplate.yaml#Elimina o pod baseado no seu manifesto$ kubectl get pod meuPod -o yaml > podTemplate.yaml$ kubectl run meuNginx --image nginx --dry-run=client -o yaml > podTemplate.yaml#Cria um modelo yaml que servirá para criar um pod.$ kubectl run meuPod --image=redis --dry-run=client -o yaml #Outro exemplo$ kubectl run meuNginx --image nginx --port 80 --dry-run=client -o yaml > podTemplate.yaml #Cria um modelo yaml especificando o porto que fica à escuta no container.
$ kubectl expose pod meunginx #Este comando cria um Service, que é utilizado para expor o pod para ser acessivel externamente.
$ kubectl get services #Ver os serviços ativos com respectivos IP e portos.
### Mais Get:
$ kubectl get all $ kubectl get pod,service $ kubectl get pod,svc$ kubectl run hello-minikube
### Eliminar o que se criou:
$ kubectl delete -f podTemplate.yaml $ kubectl delete service meuNginx
$ kubectl get pods -o jsonpath="{..image}" #Lista todas as imagens usadas nos containers no Default NS
$ kubectl delete --all pods$ kubectl cluster-info dump
### Labels e Selectors
$ kubectl get all --show-labels
$ kubectl get pod --selector env=prod
### Mais comandos (ainda em organização)
$ kubectl delete pod pod-info-deployment-869667679b-6zbcd -n development
$ kubectl exec -it busybox-55fdb79844-chq95 -- /bin/sh #Entrar no Contentor busybox
$ kubectl logs pod-info-deployment-869667679b-sz786 -n development
$ kubectl get svc - devolve o IP externo do cluster, por exemplo.
$ kubectl get deployment nginx-deplyment -o yaml
$ kubectl api-resources
$ kubectl -n kube-system get pods #Pods de sistema.
$ kubectl logs NOME_DO_POD
$ kubectl logs -f NOME_DO_POD
https://kubernetes.io/docs/reference/kubectl/
Replicaset, Scaling
$ kubectl describe rs replica-set
$ kubectl create -f podTemplate.yml #Cria um replica set.
$ kubectl get replicaset
$ kubectl delete replicaset minhaApp-replicaset.
$ kubectl replace -f podTemplate.yml #Atualiza por exemplo o ReplicaSet no caso de pretendermos alterar o número de replicas.
$ kubectl scale --replicas=6 -f podTemplate.yaml #O mesmo que o anterior, mas não é preciso editar antes o podTemplate.yml.
$ kubectl scale replicaset meuApp-replicaset --replicas=6 #O mesmo que os anteriores.
$ kubectl explain replicaset #Mostra a documentação do resource replicaset.
$ kubectl edit rs meuApp-replicaset
Deployments
$ kubectl create deployment --help
$ kubectl create deployment nomeDeployment --image=nginx --replicas=3
$ kubectl get deploy
https://kubernetes.io/docs/home/
https://kubernetes.io/docs/reference/
https://www.redhat.com/en/topics/containers/what-is-kubernetes
Identificar o novo disco adicionado:
# fdisk -lCriar um volume físico no novo disco:
# pvcreate /dev/sde
Physical volume "/dev/sde" successfully created.
Verificar que o volume físico foi bem criado:
# lvmdiskscan
/dev/sda1 [ 512,00 MiB]
/dev/sdb [ 2,00 TiB] LVM physical volume
/dev/sdc [ 175,00 GiB] LVM physical volume
/dev/sdd1 [ <1024,00 GiB] LVM physical volume
/dev/sde [ 600,00 GiB] LVM physical volume
3 LVM physical volume whole disks
1 LVM physical volumeVerificar o volume group onde é para adicionar o novo volume:
# vgs
VG #PV #LV #SN Attr VSize VFree
vg0 3 1 0 wz--n- <3,00t 0Adicionar o novo volume ao Volume Group já existente que contém o volume lógico no qual é para adicionar mais espaço:
# vgextend vg0 /dev/sde
Volume group "vg0" successfully extended
# vgs
VG #PV #LV #SN Attr VSize VFree
vg0 3 1 0 wz--n- <3,59t 599,98g
Com o espaço atribuído ao volume group, agora já se pode estender o volume lógico:
# lvextend -l+100%FREE /dev/vg0/lv0
Size of logical volume vg0/lv0 changed from <3,00 TiB (196606 extents) to <3,59 TiB (235005 extents).
Logical volume vg0/lv0 successfully resized.Por fim aumentamos a partição com o espaço atribuído ao volume lógico:
# resize2fs -p /dev/vg0/lv0
resize2fs 1.45.5 (07-Jan-2020)
Sistema de ficheiros em /dev/vg0/lv0 está montado em /dados; requerido redimensionamento em linha
old_desc_blocks = 192, new_desc_blocks = 230
O sistema de ficheiros em /dev/vg0/lv0 tem agora 962580480 (4k) blocos.Fonte:
https://www.tutorialspoint.com/how-to-increase-the-size-of-a-linux-lvm-by-adding-a-new-disk
Mensagens
