Contexto

Ataque de dicionário consiste em usar uma lista de palavras comuns para tentar descobrir um segredo (por exemplo, a senha de um usuário).

Se um site não tiver proteção, ele pode ser comprometido por esse ataque.

Nesse post, vamos mostrar como realizar um ataque de dicionário. Ao final, teremos sugestões de como se proteger.

E para testar, nosso usuário terá a senha 1234567, que é a nona senha mais comum de acordo com Wikipedia.

Atenção

Aviso de ética: Este guia é destinado apenas a fins educacionais e para testes autorizados de segurança. Certifique-se de ter permissão explícita antes de realizar ataques em qualquer sistema.

Ambiente

Para simular o ataque, vamos rodar localmente uma página simples web usando Django.

Arquivo Dockerfile

FROM python:3.12-slim

WORKDIR /app

RUN pip install Django==5.1.4 && \
    django-admin startproject myproject . && \
    echo "STATIC_ROOT = '/app/static/'" >> myproject/settings.py && \
    python manage.py migrate && python manage.py collectstatic --noinput && \
    echo "from django.contrib.auth.models import User; User.objects.create_superuser('admin', 'admin@example.com', '1234567')" | python manage.py shell

EXPOSE 8000

CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

E para rodar, basta executar o comando:

docker build -t unsafe-django .
docker run -p 8000:8000 unsafe-django`

E pronto. Você pode acessar a página em http://localhost:8000/admin/.

Burp Suite

O Burp Suite é uma das ferramentas mais populares para testes de segurança de aplicações web, amplamente utilizada por analistas de segurança e desenvolvedores para identificar vulnerabilidades como injeção de código, falhas de autenticação e exposição de dados sensíveis.

Para o ataque de dicionário, vamos usar o Intruder. Vamos fazer isso passo a passo.

Você pode instalar seguindo as intruções do link Download and Install.

Usando Intruder

Abra seu Burp Suite.

Estou usando a Community Edition, e com isso preciso apenas clicar em Next. Na janela seguinte Start Burp.

E agora temos ele pronto para começar a usar o Burp. Precisamos primeiro capturar nossa request. Vá na aba Proxy e clique em Open Browser.

Vamos usar esse Browser para detectar a request que queremos fazer o ataque. No caso, vamos fazer login.

Dentro do Browser, acesse http://localhost:8000/admin/. E no seu Burp Suite, clique em Intercept off (para começar a interceptar).

De volta ao browser, tente acessar com o usuário admin e uma senha qualquer como 123456 (supondo que não sabemos a senha do admin ainda). De volta ao Burp, você verá a request esperando. Queremos replicar ela, então clique com o botão direito e Send to Intruder.

E podemos ir para a aba Intruder.

Nessa aba nova, você verá a request que interceptamos. Selecione a senha que você utilizou e clique em Add.

Vamos usar Simple List como nosso Payload type. Com isso, iremos passar um arquivo com o nosso dicionário de senhas. Para o nosso exemplo, vou usar um dicionarário com apenas 20 senhas.

123456
password
12345678
qwerty
123456789
12345
1234
111111
1234567
dragon
123123
baseball
abc123
football
monkey
letmein
696969
shadow
master
666666

Eu peguei essas senhas do Wikipedia. Basta salvar em um arquivo e selecionar ele no Burp (clicar em Load... e selecionar seu arquivo).

Com tudo isso pronto, você terá algo parecido com isso:

Agora basta clicar em Start Attack. E você verá o Burp tentando todas as senhas do dicionário.

Após alguns instantes, você verá que a senha 1234567 foi encontrada.

Nosso resultado é esse diferente em que temos o response code 302, e podemos ver qual foi a senha que deu certo (no caso, 1234567).

Como se proteger

Para se proteger de ataques de dicionário, você pode:

Limitar o número de tentativas de login: Usar ferramentas que limitem o número de tentativas de login, como lockouts, para evitar que um atacante tente várias senhas.

Usar autenticação de dois fatores: É uma boa solução também, pois mesmo que o atacante descubra a senha, ele ainda precisará de outro fator para acessar a conta. Por outro lado, é interessante ter outras formas também, caso contrário seu site poderá ser utilizado para descobrir senhas de outros serviços - por exemplo, caso seus usuários usem a mesma senha em vários sites.

Usar senhas fortes: É comum mostrar um indicador de quão forte é a senha para que o usuário possa saber se está usando senha muito fraca e evitar que seja descoberta facilmente.

Monitorar tentativas de login: Usar um serviço de monitoramento de segurança para identificar tentativas de login suspeitas.

Login sem senha: Outra forma de se proteger é não usar senha. Existem outras formas de autenticação, como fazer o login usando o Google, Facebook, ou envio de token por e-mail.

Conclusão

Esse post foi focado em mostrar como um ataque de dicionário pode ser feito e trazer indicações de como se proteger.

Há diversas formas de se proteger, mas quis apenas explicá-las superficialmente, pois a proteção vai depender bastante de qual linguagem/frameworks você usa.

TL;DR

    def annotate_tz_aware(self, dt):
        sql_date = dt.strftime("%Y-%m-%d")
        return (
            self
            .annotate(
                dt=RawSQL("(%s || ' ' || time || ' ')::timestamp AT TIME ZONE timezone", (sql_date,)),
            )
        )

Annotate dessa linha passando a data (sql_date)

Cenário

Vamos imaginar o seguinte cenário. Você possui seu model com date e time naive com um campo separado para timezone. E na queryset você precisa ordenar ou filtrar. Você pode usar um annotation para poder ordenar o que vem antes variando com o timezone.

Por que não usar datetime com timezone convertendo para UTC em todos? No meu caso em específico, eu precisava de eventos recorrentes, preferindo deixar date e time naive, e fazendo as conversões pela própria queryset ou ao retornar ao usuário.

Código base

Tendo como base o seguinte repositório GitHub.

Vamos olhar o models.py:

class Event(models.Model):
    name = models.CharField(max_length=100)
    weekdays = models.CharField(max_length=100)
    time = models.TimeField()
    timezone = models.CharField(max_length=100)

E o seguinte teste:

    def test_sort_different_tz_events(self):
        london_event = Event.objects.create(
            name='Event 1',
            weekdays='mon,tue,wed,thu,fri',
            time='12:00',
            timezone='Europe/London',
        )
        paris_event = Event.objects.create(
            name='Event 2',
            weekdays='mon,tue,wed,thu,fri',
            time='12:01',
            timezone='Europe/Paris',
        )

        dt = date(2024, 7, 15)
        events = Event.objects.annotate_tz_aware(dt).order_by('dt')
        assert events[0] == paris_event
        assert events[1] == london_event

Nesse teste, o evento em Londres acontece às 12:00 de Londres, que seria 11:00 UTC. Mas o event de Paris deve acontecer antes, pois é 12:01 de Paris, mas 10:01 UTC.

Consegui alcançar o objetivo com RawQuery fazendo o seguinte annotation:

class EventManager(models.Manager):

    def annotate_tz_aware(self, dt):
        sql_date = dt.strftime("%Y-%m-%d")
        return (
            self
            .annotate(
                dt=RawSQL("(%s || ' ' || time || ' ')::timestamp AT TIME ZONE timezone", (sql_date,)),
            )
        )


class Event(models.Model):
    name = models.CharField(max_length=100)
    weekdays = models.CharField(max_length=100)
    time = models.TimeField()
    timezone = models.CharField(max_length=100)

    objects = EventManager()

Vou explicar cada passo do annotate_tz_aware.

• Usamos o dt para passar qual data está sendo feita a comparação. Isso é necessário pois fazemos a comparação no mesmo timezone (UTC no exemplo) e precisamos da data caso seja convertido para o dia seguinte. ** Exemplo: 2:00 em Sydney (Austrália) seriam 15h do dia anterior em UTC. Precisamos levar isso em consideração na hora da conversão. ** Por que não usar uma data aleatória? Pois dependendo da data do ano, temos o horário de verão, então essa conversão será diferente.
• "(%s || ' ' || time || ' ')::timestamp esse trecho é apenas para concatenar como um datetime sem a noção de timezone.
• AT TIME ZONE timezone vamos forçar que o resultado seja no timezone do evento. E dessa forma fazemos a comparação com o datetime ciente do timezone na hora de ordenar.

Simplificação

Esse foi um jeito bem simplificado do que fiz. No caso, não verifiquei se dt tem o weekday do evento. Mas espero ter passado a ideia principal.

Nesse post, vou explicar um pouco como fazer uma aplicação simples usando docker-compose. Farei uma aplicação web com Flask utilizando banco de dados MariaDB.

Ela será simples, sem dados ou algum migration com o banco de dados. O foco do post será entender o docker-compose.

Aplicação Flask

Usarei o Flask para essa aplicação simples. Ela terá apenas 2 endpoints. Um será apenas uma mensagem estática e o outro fará uma requisição para o banco de dados.

A estrutura será a seguinte:

├── application
│   ├── Dockerfile
│   └── src
│       ├── app.py
│       └── requirements.txt
└── docker-compose.yml

• Dockerfile contém a nossa imagem Docker.
• app.py é a nossa aplicação.
• requirements.txt contém as dependências do nosso projeto.
• docker-compose.yml é para orquestrar os nossos serviços (a aplicação e o banco de dados).

O código de exemplo está no GitLab

app.py

Nossa aplicação possui esses 2 endpoints: / e /db.

import os
import pymysql.cursors
from flask import Flask


connection = pymysql.connect(host='database',
                             user=os.getenv('MYSQL_USER'),
                             password=os.getenv('MYSQL_PASSWORD'),
                             db='application_db',
                             charset='utf8mb4',
                             cursorclass=pymysql.cursors.DictCursor)

app = Flask(__name__)


@app.route('/')
def hello():
    return f'Application /'


@app.route('/db')
def db():
    cur = connection.cursor()
    cur.execute("SELECT VERSION() AS db_version")

    version = cur.fetchone()

    return (f'Database /db<br />\n'
            f'Version of database: {version["db_version"]}')

A aplicação usa os primeiros exemplos que encontrei para flaks e pymysql.

O endpoint / é apenas para imprimir um texto simples e /db se conecta ao banco de dados e escreve a versão.

requirements.txt

Flask==1.1.1
PyMySQL==0.9.3

Esse arquivo contém as dependências do projeto.

Dockerfile

O Dockerfile tem comentários para ajudar a entender o que ele está fazendo. Ele está copiando a pasta src para a imagem, instalando os requerimentos e definindo o comando para inicializar.

FROM python:3.7

# Copy full application to the image
# For real environments, consider customize .dockerignore
COPY src /opt/application

# This is to make it easier. The defaul PWD where you
# start when using your application
WORKDIR /opt/application

RUN pip install -r requirements.txt

# Run default flask, but allow remote access
CMD flask run --host=0.0.0.0

docker-compose.yml

Esse arquivo vai listar os serviços e suas variáveis.

version: "3.7"

services:
  application:
    build: application
    links:
      - database
    ports:
      - "5000:5000"
    environment:
      FLASK_DEBUG: "1"
      MYSQL_USER: "application"
      MYSQL_PASSWORD: "password"
      MYSQL_DATABASE: "application_db"
    volumes:
      - ./application/src:/opt/application

  database:
    image: mariadb:10.4
    environment:
      MYSQL_RANDOM_ROOT_PASSWORD: "yes"
      MYSQL_DATABASE: "application_db"
      MYSQL_USER: "application"
      MYSQL_PASSWORD: "password"

O serviço de banco de dados está definindo a imagem a ser utilizada e as variáveis de ambiente. Nós não fazemos modificações na imagem.

Mas nossa aplicação precisa de customização (definida em nosso Dockerfile).

• build: application define onde o nosso Dockerfile está. Nossa imagem será criada com base nele.
• links: é a lista de conexões entre nossos serviços. Nossa aplicação precisa se conectar ao banco de dados.
• ports: é a lista de portas conectadas com o host (seu computador). Nesse exemplo, se acessar localhost:5000 no meu navegador local, ele irá responder com o localhost:5000 do container.
• environment: é a lista com a variáveis de ambiente passadas para o container.
• volumes: é a lista de volumes utilizados. Aqui, estou montando o código-fonte na imagem. A razão para isso é que se eu realizar mudanças no host, elas serão atualizadas no container. Também porque configurei no flask FLASK_DEBUG: "1".

Rodando

Agora você precisa apenas rodar com o comando docker-compose up.

Página estática

Página fazendo conexão com o banco de dados

Alguns truques

Rodar em background

Para rodar em background basta adicionar uma flag docker-compose up -d. Seu terminal não estará preso ao docker. Se você quiser ver os logs, rode docker-compose logs (para ver todos os logs), docker-compose logs -f (para ver todos os logs e seguir os seguintes) ou docker-compose logs application (para filtrar os logs de um determinado serviço).

Compose network

Não sei se você percebeu, mas não precisei mapear o hostname do banco de dados. O Docker já o criou para mim.

Isso aconteceu porque ligamos os serviços:

    links:
      - database

No caso, usamos o mesmo nome do serviço como db hostname da aplicação.

host='database',

Debug container

Você também pode inspecionar o container roando o comando docker-compose exec application bash.

Mudar portas

Você não precisa usar a porta 5000 de seu host. Você pode escoolher qualquer outra. (exemplo: no arquivo docker-compose.yml, você poderia mudar para 8000:5000)

Mudando o Dockerfile

Se você fizer mudanças que alterem a imagem gerada, será necessário build da imagem.

Por exemplo, se você começar seu projeto (docker-compose up) e depois atualizar o requirements.txt.

Você pode fazer isso rodando docker-compose build.

Nesse post, explicarei um pouco como usar o Docker. Basicamente, vou abordar o comando run a alguns truques.

Run

Esse comando vai rodar um container com uma imagem já existente.

Se você quiser rodar o Ubuntu localmente, deve rodar apenas docker run ubuntu.

$ docker run -it ubuntu
root@aacdec8ea1e8:/# echo test
test
root@aacdec8ea1e8:/#

A primeira linha (docker run -it ubuntu) rodou no meu host (meu Sistema Operacional, não no container docker). A segunda linha (echo test) rodou no container Ubuntu.

P.S.: A flag -it é para conectar o seu terminao com o container (para ver o que acontece dentro do container).

Poderiamos user outras imagens (debian, centos, python…). No Docker Hub você pode encontrar diversas outras imagens.

Usar outra versão

Também é possível usar diferentes versões do Ubuntu. Nós precisamos apenas usar uma tag diferente para a versão.

Podemos usar o Ubuntu 19.04 usando o comando docker run ubuntu:19.04.

$ docker run -it ubuntu:19.04
root@bc620ad9745b:/# cat /etc/*release | grep VERSION_ID
VERSION_ID="19.04"
root@bc620ad9745b:/# exit
exit
$ docker run -it ubuntu
root@6acfdb1bff1d:/# cat /etc/*release | grep VERSION_ID
VERSION_ID="18.04"

Por padrão, usa-se a tag latest, ou seja, rodar o comando docker run ubuntu é o mesmo que rodar docker run ubuntu:latest. Hoje, o latest é o mesmo que 18.04. No lançamento do próximo Ubuntu LTS a versão latest será a 20.04.

Mudar o comando padrão

Cada imagem tem um comando padrão para rodar. Quando usamos docker run -it ubuntu, ele automaticamente roda bash. Mas quando usamos uma imagem python, ele roda o comando python.

$ docker run --rm -it python
Python 3.7.4 (default, Aug 14 2019, 12:09:51)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print('hello')
hello

Você pode mudar o comando padrão. Por exemplo, caso queira instalar algo antes do comando padrão.

$ docker run --rm -it python bash
root@1db1de2e11cc:/# pip install awscli
Collecting awscli
  Downloading https://files.pythonhosted.org/packages/97/72/bafa0c932416fb91c87f172cd4b0fdff5be32e4d01a3c89c8ae03549d7c3/awscli-1.16.229-py2.py3-none-any.whl (2.0MB)
     |████████████████████████████████| 2.0MB 2.2MB/s
...
Building wheels for collected packages: PyYAML
  Building wheel for PyYAML (setup.py) ... done
  Created wheel for PyYAML: filename=PyYAML-5.1.2-cp37-cp37m-linux_x86_64.whl size=468680 sha256=df0859d47787aaf4e7b2b2e1f5720ab061297d9b3c2519b32f5254217b77fd51
  Stored in directory: /root/.cache/pip/wheels/d9/45/dd/65f0b38450c47cf7e5312883deb97d065e030c5cca0a365030
Successfully built PyYAML
Installing collected packages: pyasn1, rsa, docutils, six, python-dateutil, urllib3, jmespath, botocore, s3transfer, colorama, PyYAML, awscli
Successfully installed PyYAML-5.1.2 awscli-1.16.229 botocore-1.12.219 colorama-0.3.9 docutils-0.15.2 jmespath-0.9.4 pyasn1-0.4.6 python-dateutil-2.8.0 rsa-3.4.2 s3transfer-0.2.1 six-1.12.0 urllib3-1.25.3
root@1db1de2e11cc:/# python
Python 3.7.4 (default, Aug 14 2019, 12:09:51)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import awscli
>>> # Do things with awscli

Conectar de um terminal diferente

Vamos rodar o servidor em um terminal e criar arquivos em outro.

Terminal 1

$ docker run -it -p 8000:8000 python bash
root@1e171a55d01f:/# python -m http.server 8000
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Terminal 2

Execute o comando ps para obter o container ID e se conectar ao container usando o comando exec.

$ docker ps
CONTAINER ID        IMAGE                  COMMAND                  CREATED             STATUS              PORTS                                              NAMES
1e171a55d01f        python                 "bash"                   42 seconds ago      Up 41 seconds       0.0.0.0:8000->8000/tcp                             stupefied_heyrovsky

$ docker exec -it 1e171a55d01f bash
root@1e171a55d01f:/# ls
bin  boot  dev	etc  home  lib	lib64  media  mnt  opt	proc  root  run  sbin  srv  sys  tmp  usr  var
root@1e171a55d01f:/# echo 'My site' > index.html

Se você acessar localhost:8000 verá a página simples que acabou de ser criada.

Dicas

Usar a flag –rm

Quando você roda esses comandos os containers são criados mas não apagados depois de utilizá-los. No fim, você terá diversos containers antigos ocupando espaço.

Você pode encontrar esses containers rodando docker ps -a.

$ docker ps -a
CONTAINER ID        IMAGE                  COMMAND                  CREATED             STATUS                      PORTS                                              NAMES
1e171a55d01f        python                 "bash"                   10 minutes ago      Up 10 minutes               0.0.0.0:8000->8000/tcp                             stupefied_heyrovsky
6acfdb1bff1d        ubuntu                 "/bin/bash"              2 hours ago         Exited (0) 22 minutes ago                                                      cranky_booth
bc620ad9745b        ubuntu:19.04           "/bin/bash"              2 hours ago         Exited (0) 2 hours ago                                                         gracious_hopper

Se você rodar a flag --rm isso não acontecerá. Por exemplo: docker run -it --rm ubuntu.

Limpar Imagens

Você também pode limpar espaço rodando o comando prune.

$ docker system prune -a
WARNING! This will remove:
  - all stopped containers
  - all networks not used by at least one container
  - all images without at least one container associated to them
  - all build cache

Are you sure you want to continue? [y/N] y
...

Por agora, esse comando não tempo problema pois não criamos muitas coisas. Mas precisa tomar cuidado para não apagar nada importante (se por acaso algo importante estiver rodando, ele não será apagado).

Resumo

Esse é apenas o básico de tarefas com o docker. Espero que você tenha entendido um pouco mais sobre ele.

Outra possibilidade é rodar 2 containers (por exemplo, um site PHP e um banco de dados). Eu expliquei no StackOverflow como fazer isso.

Isso é interessante para o aprendizado, mas eu prefiro usar o docker-compose para isso.

Veja o post sobre docker-compose.

Esse tutotial ensina como fazer um PR (Pull Request, que é integrar seu código git)

Pegue o código

Usarei o meu repositório pr tutorial repository como examplo. Você pode usá-lo, mas eu recomendo que você use o seu próprio.

git clone git@gitlab.com:rafaelhdr/pr-example.git

Use código recente

(você pode pular esse passo, se clonou o repositório)

A maioria do tempo você não estará clonando um repositório, mas usando um já existente. Nesse caso, vá para a branch master e atualize o código.

git checkout master para ir a branch master

git pull origin master para atualizar com o código mais recente

Branch

Vamos criar um novo branch com as mudanças. Criaremos o novo branch, e faremos um Pull Reqquest para integrar o código com suas mudanças à branch master (normalmente master, mas pode ser outra).

git branch make-chapter-2 para criar a nova branch make-chapter-2

git checkout make-chapter-2 para ir a essa nova branch

Dica: Os dois comandos acima poderiam ser substituídos por git branch -b make-chapter-2

Mude algo no código (examplo: adicione um parágrapho lorem ipsum a content.txt).

git add content.txt para adicionar o código ao commit

git commit -m "make chapter 2" para criar um commit com essas mudanças

Agora, seu código local está atualizado. We precisamos apenas colocar no servidor (no meu caso, GitLab).

git push origin make-chapter-2

Pronto

O código está pronto. Você pode vê-lo no GitLab (e integrar de lá).

Esse tutorial é para deploy de uma aplicação simple no Google Kubernetes Engine.

Mas para começar, você precisa de:

• gcloud linha de comando instalada e configurada
• kubectl linha de comando instalada

É melhor se você já souber os básico de Docker. Eu criei uma imagem rafaelhdr/server-hello para isso. Essa imagem apenas responde Hello, World! para GET /.

Crie o cluster

gcloud container clusters create hello-cluster

Esse comando irá criar seu cluster kubernetes. Depois de um tempo irá aparecer:

...
NAME           LOCATION       MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
hello-cluster  us-central1-a  1.8.10-gke.0    35.226.200.163  n1-standard-1  1.8.10-gke.0  3          RUNNING

Deploy da aplicação

Nós temos nosso cluster mas nenhuma aplicação rodando. Veja com os comandos abaixo.

$ kubectl get deployment
No resources found.

$ kubectl get pods
No resources found.

Então vamos colocar nossa aplicação. Crie o arquivo de configuração sh-service-lb.yaml:

Se quiser usar sua própria aplicação, mude image e cointanerPort.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: sh-deployment
  labels:
    app: sh-deployment
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: sh-deployment
    spec:
      containers:
        - name: sh-deployment
          image: rafaelhdr/server-hello
          ports:
            - containerPort: 5000

Para deploy em nosso cluster, rode:

$ kubectl apply -f sh-deployment.yaml 
deployment.extensions "sh-deployment" created

Fizémos o deploy de nossa aplicação. Você pode checar rodando:

$ kubectl get deployment
NAME            DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
sh-deployment   2         2         2            2           39s

$ kubectl get pods
NAME                             READY     STATUS    RESTARTS   AGE
sh-deployment-6db6b8856d-q9j95   1/1       Running   0          53s
sh-deployment-6db6b8856d-tgmmh   1/1       Running   0          53s

O que fizémos? - Criamos duas replicas de nossa aplicação em nosso cluster (replicas: 2). É por isso que temos 2 pods e um deployment.

O que é um Pod? É a menos unidade que colocamos no Kubernetes. Nós poderíamos ter dois containers rodando juntos, de forma que compartilhariam o mesmo volume.

O problema é que ele ainda não está exposto. Vamos criar o Load Balancer.

Serviço Load Balancer

Nós vamos seguir os mesmos passos (criar arquivo de configuração e apply usando kubectl). Crie o arquivo sh-service-lb.yaml.

apiVersion: v1
kind: Service
metadata:
  name: sh-service
  labels:
    app: sh-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 5000
  selector:
    app: sh-deployment

Agora nós rodamos o mesmo comando para esse arquivo:

$ kubectl apply -f sh-service-lb.yaml
service "sh-service" created

O que fizémos? Criamos nosso Load Balancer redirecionando requests de acesso externo (porta 80) para nosso container (porta 5000).

Certo. Nosso serviço foi criado, mas precisa de um tempo para iniciar. Espere o EXTERNAL-IP mudar de PENDING para um valor real:

$ kubectl get services
NAME         TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
kubernetes   ClusterIP      10.15.240.1     <none>        443/TCP        25m
sh-service   LoadBalancer   10.15.241.155   <pending>     80:30138/TCP   1s

# Wait some time

$ kubectl get services
NAME         TYPE           CLUSTER-IP      EXTERNAL-IP     PORT(S)        AGE
kubernetes   ClusterIP      10.15.240.1     <none>          443/TCP        27m
sh-service   LoadBalancer   10.15.241.155   35.192.86.102   80:30138/TCP   1m

Meu IP externo é 35.192.86.102. Pegue o seu IP externo e acesse de seu navegador (http://YOUR_EXTERNAL_IP/).

Acessando a interface web

Pegue o token de acesso rodando kubectl -n kube-system describe secret $(kubectl -n kube-system get secret | awk '/^deployment-controller-token-/{print $1}') | awk '$1=="token:"{print $2}'.

Acesse a interface localmente por um proxy rodando kubectl config view e abrindo http://127.0.0.1:8001/ui/. Para Sign In, use o token obtido anteriormente.

Apague tudo

Certo, fizémos nossos testes. Podemos remover tudo apagando nosso cluster.

$ gcloud container clusters delete hello-cluster
The following clusters will be deleted.
 - [hello-cluster] in [us-central1-a]

Do you want to continue (Y/n)?  Y

...

Resumo

Nesse tutorial, criamos um cluster, colocamos nossa aplicação e um load balancer nele, acessamos a interface web e então deletamos esse cluster.

Esse é apenas o começo para o Kubernetes, mas fizémos apenas o básico. Tentarei fazer mais posts sobre Kubernetes. Enquanto isso, você poderia ver Learn Kubernetes in Under 3 Hours: A Detailed Guide to Orchestrating Containers. É um tutorial mais completo que esse, aprendendo os conceitos que testamos aqui mais profundamente, mas em um cluster local.

Referências:

• How to sign in kubernetes dashboard?
• Quickstart - GKE
• Hello World Walkthrough

Nesse post, vou escrever uma função simples full_profile explicando alguns conceitos sobre os parâmetros de Python. Con isso, poderemos entender como a famosa função my_function(*args, **kwargs) funciona.

Argumento de posição (Positional argument)

Esse é o primeiro tipo de parâmetro que vemos. A sequência de argumentos dada é usada:

def full_profile(id, name, age):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")

full_profile(1, "rafael", 30)

Resultado:

Id: 1
Name: rafael
Age: 30

Argumento de palavra-chave (Keyword argument)

Algumas vezes é melhor usarmos argumento de palavra-chave para ficar mais legível.

def full_profile(id, name, age):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")

full_profile(1, name="rafael", age=30)

Resultado:

Id: 1
Name: rafael
Age: 30

Em minha opinião, prefiro argumento de palavra chave pois é mais explícito (mas nem sempre, como por exemplo em soma(1, 2) por não fazer diferença a ordem).

Forçar argumento de palavra-chave

Se você trocar a ordem dos argumentos, pode ter o seguinte problema:

def full_profile(id, name, age):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")

# If you change the order for some reason, the result will be wrong
full_profile(1, 30, "rafael")

Resultado:

Id: 1
Name: 30
Age: rafael

Você pode forçar o argumento ser de palavra chave usando *:

def full_profile(id, *, name, age):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")

# This will not work anymore
full_profile(1, 30, "rafael")

# This will work
full_profile(1, name="rafael", age=30)

# This result is the same
full_profile(1, age=30, name="rafael")

Resultado:

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
TypeError: full_profile() takes 1 positional argument but 3 were given

Id: 1
Name: rafael
Age: 30

Id: 1
Name: rafael
Age: 30

Adicionar argumentos de posição não definidos

Se quisermos adicionar mais informações passadas pelo usuário, mas não definidas na função, podemos usar args.

def full_profile(id, *args, name, age):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")
    for arg in args:
        print(arg)

full_profile(1, "I am a developer", name="rafael", age=30)

Resultado:

Id: 1
Name: rafael
Age: 30
I am a developer

Agora entendemos os *args do padrão my_function(*args, **kwargs).

Nós não precisamos usar o nome args. Poderia ser algum outro nome, como extra. É apenas umas convenção.

Adicionando argumentos de palavras-chave não definidos

Se precisarmos de mais informações passadas pelo usuário, mas não definidos pela função, podemos usar kwargs.

def full_profile(id, *args, name, age, **kwargs):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

full_profile(1, "I am a developer", name="rafael", age=30, Company="rafaelhdr")

Resultado:

Id: 1
Name: rafael
Age: 30
I am a developer
Company: rafaelhdr

E agora entendemos o **kwargs do padrão my_function(*args, **kwargs).

Novamente, kwargs é a convenção, mas você pode escolher outro nome.

Se usarmos o padrão my_function(*args, **kwargs) ele aceitará todos os casos. Mas os argumentos são todos opcionais. Se definirmos ele na função e o usuário não fornecê-lo, será levantado um erro:

def full_profile(id, *args, name, age, **kwargs):
    print(f"Id: {id}")
    print(f"Name: {name}")
    print(f"Age: {age}")
    for arg in args:
        print(arg)
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# age is removed of the arguments
full_profile(1, "I am a developer", name="rafael", Company="rafaelhdr")

Resultado:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: full_profile() missing 1 required keyword-only argument: 'age'

args e kwargs

Podemos pensar em *args como uma lista de argumentos de posição não definidos e **kwargs é um Dicionário de argumentos de palavra-chave não definidos.

Referência

Python Glossary - term parameter

Você tem um arquivo muito grande, e quer extrair algum valor em específico. Você pode usar substituição com expressão regular.

Certo, não é apenas com VIM. Você poderia usar o grep também. Estou usando VIM pela facilidade no post.

Sim, você poderia usar um crawler para isso. No meu caso, eu só queria extrair esses valores de um único arquivo.

TL;DR

:%g!/useful-class/d
:%s/<a.*href="\([^"]*\).*\n/\1\r/g

Arquivo de teste

Para testar, você pode abrir o seguinte arquivo no VIM:

SOME BIG HTML
<a class="useful-class" href="http://example/1">Example 1</a>
NOT USEFUL LINE
<a class="useful-class" href="http://example/2">Example 2</a>
END OF BIG HTML

Em nosso exemplo, queremos remover as linhas inúteis e deixar apenas a URL.

Comandos

Limpar as linhas inúteis:

:%g!/useful-class/d

• %g! Fazer algo em todas as linhas que não contenham certa expressão
• useful-class A expressão que estamos procurando. No caso, queremos encontrar useful-class
• d Definimos que queremos deletar quando não encontrar a expressão

Remover conteúdo inútil:

:%s/<a.*href="\([^"]*\).*\n/\1\r/g

• %s Substituir todas as linhas que possuam certa expressão
• Expressão (esse é longo):
  • <a Que começa com <a
  • .* Com qualquer caracter até…
  • href=” …até que encontre href="
  • \([^”]*\) e a primeira parte (chamada de “atom”) é qualquer coisa que não contenha aspas([^"]* sem aspas). O “atom” é o conteúdo entre os parênteses((...))
  • .* e qualquer caracter até…
  • \n …até que encontre uma nova linha \n
• \1\r e substituir pelo primeiro “atom” e uma nova linha
• g rodar o comando

Done

O resultado é esse:

http://example/1
http://example/2

Não é simples, mas da segunda vez é mais fácil de lembrar.

Eu usei hoje para limpar um simples arquivo longo (copiei o DOM <ul><li><a>...</a></li></ul>) e rodei os comandos (ao mesmo tempo que ia aprendendo também).

Referências

• Delete all lines containing a pattern
• Replace while keeping certain “words” in vi/vim
• How to replace a character by a newline in Vim?

Olá, meu nome é Rafael e sou desenvolvedor web desde 2003. Se você está aqui, talvez esteja interessado em me contratar como desenvolvedor, então gostaria de falar um pouco mais sobre minhas habilidades.

No texto, estou adicionando alguns links a projetos open-source relacionados.

Minha principal habilidade é de backend. Eu gosto das linguagens Node.js e Python. Você poderia me contratar também para desenvolver em Golang, mas ainda sou iniciante em Go. Tenho experiência desenvolvendo aplicações monolíticas com Django e também Microserviços usando Express, Flask e Django.

Também sei frontend. Possuo as habilidades básicas de HTML/CSS/js e também desenvolvo usando React, tanto para single-page application (create-react-app my-app) como adicionando componentes em uma aplicação já existente.

DevOps é algo que gosto bastante. Comecei aprendendo Linux alguns anos atrás (~desde 2013) e Docker desde 2016. Hoje em dia, tento sempre desenvolver minhas aplicações utilizando GitLab CI e Docker Swarm.

Veja minha trajetoria

Já trabalhei com Startups (Dagood, buscador de bares, baladas e restaurantes, e Helpin, para contratar prestadores de serviços) e na área de Inovação (LARC/Scopus, um laboratório da USP desenvolvendo e pesquisando para a Scopus, que é uma empresa parceira do Bradesco).

E-mail: contato@rafaelhdr.com.br.

Se você cometeu algum erro em um commit anterior do git e quer editá-lo, você pode usar o git rebase para isso.

Não é recomendado se você já subiu com git push

tl;dr git rebase -i COMMITHASH

Vou explicar como fazer com um exemplo completo:

Criando o cenário

Com os comandos abaixo, você terá três commits.

git init
echo "first commit" > file0.txt
git add .
git commit -m "first commit"
echo "some code
password forgotten
more code" > file1.txt
git add .
git commit -m "commit 1"
echo "more code" > file2.txt
git add .
git commit -m "commit 2"

Temos três arquivos (file0.txt, file1.txt e file2.txt), mas um deles tem a senha escrita que foi adicionado no “commit 1”.

git rebase

Podemos usar o git rebase com hash ou então há 2 commits atrás.

git rebase -i HEAD^2
# OR
git rebase -i COMMIT_1_HASH

Você verá algo assim (com hash diferente);

pick 3aa4948 commit 1
pick 9e5aadf commit 2

# More code, even explaining the options

Nós queremos editar o “commit 1”, então vamos mudar de pick para edit no “commit 1”:

edit 3aa4948 commit 1
pick 9e5aadf commit 2

Poderíamos ter utilizado apenas e ao invés de edit.

E agora estamos no “commit 1”. Vamos remover a linha password forgotten e refazer o commit.

echo "some code
more code" > file1.txt
git add .
git commit --amend # We are editing an existent commit

E está pronto. Nós precisamos deixar o git continuar o processo com o comando git rebase --continue.

Você verá a seguinte mensagem: Successfully rebased and updated refs/heads/master.

E agora está pronto para o push.

Cuidado

Se você já fez push antes, provevalmente terá problemas. É melhor editar o arquivo (e mudar sua própria senha).

Nota sobre o primeiro commit

O primeiro commit não é importante. Por que eu o adicionei? Porque o git rebase seria um pouco diferente.

Se você tentar git rebase -i HEAD~3 terá o seguinte erro:

fatal: Needed a single revision
invalid upstream 'HEAD~3'

Precisaria no caso usar git rebase -i --root.

Referência

Git Rebasing