DEV Community: Rafael Rotiroti

Como Limitar e Proteger suas APIs com Rate Limit?

Rafael Rotiroti — Mon, 31 Mar 2025 16:31:17 +0000

As APIs são a espinha dorsal das aplicações modernas, permitindo a comunicação eficiente entre clientes e servidores. No entanto, uma API sem proteção contra requisições excessivas pode ser vítimas de ataques, levando à degradação do desempenho, aumento dos custos de infraestrutura ou até mesmo à indisponibilidade do serviço.

Por que o Rate Limiting é importante?

O Rate Limiting é um mecanismo essencial para garantir a estabilidade, segurança e uso justo de uma API. Ele ajuda a:

Prevenir abusos – Usuários mal-intencionados ou bots podem sobrecarregar uma API com requisições, tentando explorar vulnerabilidades ou derrubar o serviço.
Reduzir custos de infraestrutura – Um tráfego descontrolado pode aumentar os custos com servidores e impactar a escalabilidade da aplicação.
Garantir uso justo – As limitações evitam que um único cliente monopolize os recursos da API, distribuindo melhor a carga.
Mitigar ataques DDoS – Ao restringir o número de requisições por usuário ou IP, a API fica mais resistente a ataques de negação de serviço.

Onde o Rate Limiting é utilizado?

O Rate Limiting é amplamente aplicado em diversos setores, como:

Redes Sociais – Para evitar spam e abuso de bots (exemplo: o Twitter limita a quantidade de tweets postados por hora).
E-commerce – Para impedir que robôs sobrecarreguem páginas de produtos ou ferramentas de rastreamento de preços.
Serviços Financeiros – Para proteger APIs bancárias contra transações automatizadas excessivas.
Aplicações SaaS – Para diferenciar planos gratuitos e pagos, limitando o número de requisições por usuário.

Hands on!

Implementando Rate Limiting no FastAPI com Redis

Uma abordagem comum para implementar rate limiting é utilizar o Redis como um armazenamento em memória para rastrear requisições por usuário, token ou IP. O FastAPI permite a fácil integração de middlewares para aplicar essas restrições de forma eficiente. A ideia é interceptar a request antes que ela passe para sua funcionalidade principal, o Middleware vai verificar se há espaço para uma nova requisição, se tiver ela permite seguir, se não retorna imediatamente um Status Code 429 "Too Many Requests".

Supondo que já possua o FastApi up & running:

pip install redis

Vamos criar a classe RateLimiter:

Nesse caso optei por colocar um limite de 10 requests a cada 1 minuto. No final mostrarei os resultados...

class RateLimiter:
    """
    Rate Limiter para APIs.
    Limita o número de requisições por usuário em um determinado intervalo de tempo
    redis_client: Cliente Redis para armazenar os dados de rate limiting
    max_requests: Número máximo de requisições permitidas
    window: Intervalo de tempo em segundos
    """

    def __init__(self, redis_client, max_requests=10, window=60):
        self.redis = redis_client
        self.max_requests = max_requests
        self.window = window

    def allow_request(self, user_id) -> bool:
        """Verifica se a requisição pode ser processada dentro do limite."""
        now = time.time()
        key = f"rate_limit:{user_id}"

        pipe = self.redis.pipeline()
        pipe.zadd(key, {now: now})
        pipe.zremrangebyscore(key, 0, now - self.window)
        pipe.zcard(key)
        pipe.expire(key, self.window * 2)

        _, _, request_count, _ = pipe.execute()

        result = request_count <= self.max_requests

        return result

Configurando a aplicação (normalmente no seu main.py ou app.py):

redis_client = redis.Redis(host='redis', port=6379, db=0)

Criando o Middleware

@app.middleware("http")
async def rate_limit_middleware(request: Request, call_next):
    """Middleware de rate limiting para todas as rotas"""
    user_id = request.headers.get('X-User-ID', 'anonymous')

    if not limiter.allow_request(user_id):
        return JSONResponse(
            status_code=429,
            content={"message": "Limite de requisições excedido"}
        )

    response = await call_next(request)
    return response

Para testar, basta configurar o Insomnia, Postman ou qualquer ferramenta que possa simular cargas!

No nosso caso aqui, utilizei o Insomnia! Segue as evidências:

O código fonte está no seguinte repo. Podem utilizar para estudos e afins! Há um uso do Locust como teste de carga dentro da pasta load_test/

Conclusão

O Rate Limiting é uma estratégia fundamental para proteger APIs e garantir um uso equilibrado e manter a performance. Integrando Redis com FastAPI, os desenvolvedores podem aplicar essas restrições de forma eficiente, tornando suas APIs mais robustas e escaláveis.

Links úteis e inspirações:

Simple and Functional PHP Environment Setup with Windows

Rafael Rotiroti — Thu, 20 Feb 2025 12:07:58 +0000

PHP was my first programming language that i worked, but in the past 8 years i've been working with another technologies such as Python, Java, Javascript. I never forgot PHP because this language helped me bills paid.

In the past, most of the time i used XAMPP, MAMP or any {x}AMP stack to setup my environment... so after i worked with many other languages and learned how to setup many kind of environments i thought how do that in PHP in the right way (at least for me).

So let's get started.

My proposal is use PHP, Composer and MySQL as database.

Lets go to PHP website and download any top version as Non Thread Safe zip.

Extract to your root C:/ in path php so everything should be inside C:/php folder.

Now download Composer, run your Composer-Setup.exe and probably he will identify your PHP in your Root C:/ folder.

Finishing Composer Setup and Running Laravel with Docker Compose

After installing Composer, open your terminal and verify the installation by running:

composer --version

If you see the version number, Composer is ready. Cause not, try do restart your Windows.

Now let's set up a Laravel project

Open your terminal and run the following command to create a new Laravel application:

composer create-project --prefer-dist laravel/laravel my-laravel-app

Navigate to the project folder:

cd my-laravel-app

Install Laravel dependencies:
composer install or composer i

Copy the .env.example to .env:

cp .env.example .env

Generate the application key:

php artisan key:generate

We should need a Database.. lets configure an Docker Compose for MySQL and phpMyAdmin for managing it

Inside your Laravel root directory, create a docker-compose.yml file and paste the following configuration:

version: '3.8'
services:
  db:
    image: mysql/mysql-server:latest
    container_name: mysql-db-container
    restart: always
    environment:
      - MYSQL_DATABASE=database
      - MYSQL_USER=admin
      - MYSQL_PASSWORD=password
      - MYSQL_ROOT_PASSWORD=password
    ports:
      - '3306:3306'
    volumes:
      - mysql-volume:/var/lib/mysql
    command: --sql_require_primary_key=0
    networks:
      - mysql-phpmyadmin

  phpmyadmin:
    depends_on:
      - db
    image: phpmyadmin
    restart: always
    ports:
      - "8090:80"
    environment:
      - PMA_HOST=db
      - MYSQL_USER=admin
      - MYSQL_ROOT_PASSWORD=password
    networks:
      - mysql-phpmyadmin

networks:
  mysql-phpmyadmin:

volumes:
  mysql-volume:
    driver: local

Update Laravel's .env to connect to MySQL

DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=database
DB_USERNAME=admin
DB_PASSWORD=password

Starting Docker Containers

Run the following command to start MySQL and phpMyAdmin:

docker compose up -d

Access phpMyAdmin at http://localhost:8090. You can use the username and password given at docker-compose.yml

Now, you can start Laravel's local development server by running:

php artisan serve

Access your Laravel application at http://127.0.0.1:8000.

And that’s it! You've successfully set up a PHP environment with an Laravel project with MySQL using Docker Compose. Happy coding!

Rodando Modelos LLM Localmente com Ollama

Rafael Rotiroti — Wed, 29 Jan 2025 13:23:32 +0000

A IA tem dominado os palcos nos últimos anos e, cada vez mais, tem ganhado espaço com empresas, profissionais, estudantes... na verdade, em quase tudo.

Desde então, a IA Generativa tem sido assunto em todos os lugares. Ao utilizarmos ChatGPT, Gemini e DeepSeek, estamos usufruindo de LLMs. Um LLM (Large Language Model), que em português significa Modelo de Linguagem em Larga Escala, é um tipo de IA Generativa treinada com um volume imenso de dados. Para entender e se aprofundar mais sobre as diferenças entre alguns tipos de IA, este excelente artigo do Hugo Cardoso pode ajudar.

Quem utiliza no dia a dia as versões gratuitas do ChatGPT ou Gemini sabe que, em determinado momento, é necessário esperar algumas horas, trocar de modelo (ex: GPT-4o, mini) ou assinar o "premium". Isso acontece porque, obviamente, nem tudo é de graça (faz parte do modelo de negócio) mas também porque a execução desses modelos é custosa. O processo exige alto consumo de hardware e tráfego de rede para atender à demanda, principalmente em larga escala, como estamos vendo no mundo inteiro.

Uma solução para utilizar modelos atualizados e com muitos parâmetros é rodá-los localmente. Além de reduzir custos (evitando pagar por uma versão premium), essa abordagem pode oferecer mais desempenho (dependendo do seu hardware) e, com certeza, mais privacidade. E é isso que vamos aprender a fazer a seguir.

Instalando o Ollama

Para rodarmos LLMs localmente, precisamos de uma ferramenta que as execute. Neste caso, vamos usar o Ollama. Basicamente, o Ollama funciona como um gerenciador e runtime de modelos LLM.

No meu caso, estou usando Linux, então a instalação pode ser feita com:

No meu caso estou usando Linux entao:

curl -fsSL https://ollama.com/install.sh | sh

1.1 Configurando o Ollama

Para rodarmos LLMs localmente, precisamos de uma ferramenta que as execute. Neste caso, vamos usar o Ollama. Basicamente, o Ollama funciona como um gerenciador e runtime de modelos LLM.

No meu caso, estou usando Linux, então a instalação pode ser feita com:

ollama pull deepseek-r1

ou se escolher outro modelo..

ollama pull [nome-modelo]

Neste caso, optei pelo modelo DeepSeek, a febre do momento. Mas você pode encontrar todos os modelos disponíveis aqui: Ollama LIbrary

Aguarde o download finalizar e o modelo estará pronto para uso.

Utilizando o Ollama

Temos algumas opções para rodar os modelos localmente. Podemos fazer isso de três formas, e vou ser direto em cada uma delas:

Rodar via CLI

Conectar via Software (ex: LM Studio)
Usar via REST API

Possibilidades, prós e contras.

Rodar um modelo LLM localmente abre um leque de possibilidades para desenvolvedores, pesquisadores e empresas. Dependendo do hardware disponível, é possível consumir modelos mais completos a um custo reduzido, treinar modelos personalizados e até integrá-los em aplicativos e serviços profissionais. No entanto, essa abordagem também traz desafios que precisam ser considerados.

✅ O que eu gostei

Baixo custo: Sem taxas recorrentes de nuvem, basta ter o hardware certo.
Modelos mais robustos: Acesso a LLMs avançados sem restrições de provedores.
Privacidade: Os dados ficam locais, garantindo maior segurança.
Personalização: Possibilidade de fine-tuning para necessidades específicas.
Aplicações comerciais: Uso offline em apps, chatbots e automação.

⚠️ O que eu percebi

Alto consumo de recursos: Requer GPUs potentes e muita RAM.
Configuração complexa: Instalação e otimização podem ser trabalhosas.
Manutenção constante: Atualizações e melhorias precisam ser feitas manualmente.
Treinamento exige investimento: Fine-tuning pode demandar hardware caro.

Rodar LLMs localmente pode ser uma solução econômica e eficiente, mas exige planejamento e infraestrutura adequada. 🚀

Utilizando Dotenv para Gerenciamento de Variáveis de Ambiente e Alembic

Rafael Rotiroti — Thu, 21 Dec 2023 17:56:06 +0000

Introdução

Em meus projetos, especialmente ao trabalhar em ambientes de desenvolvimento local, utilizo variáveis de ambiente como uma estratégia eficaz para separar configurações sensíveis, como chaves de API e credenciais de banco de dados. Neste artigo, aprofundaremos no conceito de Dotenv, destacando seus benefícios e explorando como posso integrá-lo ao Alembic, por exemplo, para facilitar o gerenciamento de migrações de banco de dados. Aqui também falarei sobre vantagens e algumas desvantagens ao usá-lo.

O que é Dotenv?

Dotenv é uma biblioteca popular em várias linguagens de programação, incluindo Python, que permite carregar variáveis de ambiente de um arquivo .env para o ambiente em que minha aplicação está sendo executada. Em vez de definir variáveis de ambiente diretamente no sistema operacional ou em um serviço de hospedagem, posso armazená-las em um arquivo .env na raiz do meu projeto.

Vantagens ao usar `.env`

Isolamento e Segurança

Ao usar um arquivo .env, você mantém suas variáveis de ambiente em um local isolado, separado do código-fonte. Isso ajuda a garantir que informações sensíveis, como chaves de API e credenciais, não sejam expostas inadvertidamente.

Portabilidade

Com o Dotenv, é fácil mover seu projeto entre diferentes ambientes (dev, homol, prod) sem modificar as variáveis de ambiente. Basta ter um arquivo .env correspondente para cada ambiente.

Facilidade de Configuração

Gerenciar variáveis de ambiente através de um arquivo .envsimplifica a configuração e inicialização de seu projeto, especialmente quando você não está trabalhando sozinho.

Hands On!

Caso queira ver o projeto, eu subi o repo no github :).

Configure o ambiente

Com seu venv criado instale o python-dotenv, no exemplo vamos utilizar o alembic, então:

pip install alembic python-dotenv

Crie o seu arquivo .env e insira a variavel de ambiente da seguinte forma:

DATABASE_URL=postgresql://db_username:db_pw@localhost/db_name

Observe que o DATABASE_URL está em CAPS e o valor após o = está fora de aspas duplas (ou simples).

OBS: no repositorio tem um exemplo subindo o postgres com o docker.

Configurando o Alembic

Para iniciar o alembic rode o comando: alembic init alembic (modulo -- comando -- pasta destino)

Na raiz do projeto será criado uma pasta chamada alembic e dentro dela tem um arquivo Env.py que vamos edita-lo para usar o python-dotenv

A função load_dotenv() faz com que ela enxergue o arquivo .env na raiz do seu projeto, carregando todas as variáveis que você criar para dentro do seu projeto.

Para utilizar, basta chamar a sua variável da seguinte forma: os.getenv("NOME_VAR")

Voltando para configuração do Alembic, para que ele consiga enxergar a variável de conexão com o banco de dados basta ajudar o código da função run_migrations_online

OBS: Veja que na imagem há o config, ele puxa a configuração do arquivo alembic.ini da raiz, caso não utilize .env, por padrão é necessário alterar lá. Essa é uma das vantagens de se usar o python-dotenv.

Agora basta rodar a migration:

Utilizando o Dotenv, tenho uma maneira conveniente e segura de gerenciar variáveis de ambiente em meus projetos Python. Ao combinar essa prática com ferramentas como Alembic, posso manter um gerenciamento eficiente de configurações sensíveis e simplificar a migração de banco de dados em multiplos ambientes.

Mas nem tudo são flores...

Há desvantagens em usar Dotenv.

Complexidade em Ambientes Distribuídos

Em ambientes distribuídos ou em sistemas orquestrados como Kubernetes, gerenciar variáveis de ambiente com um arquivo .env pode não ser a abordagem mais eficiente. Nestes casos, ferramentas específicas de gerenciamento de configuração ou serviços de segredos podem ser mais apropriados (Hashicorp Vault, AWS Secrets Manager).

Risco de Exposição

Se o arquivo .env contiver informações sensíveis e não for tratado corretamente (por exemplo, não sendo incluído no .gitignore), existe o risco de expor informações sensíveis, especialmente se o código-fonte for compartilhado ou versionado publicamente.

Dependência Externa

Embora o Dotenv seja uma ferramenta útil, introduzir uma dependência externa em seu projeto pode aumentar a complexidade, especialmente se você estiver trabalhando em um ambiente onde a gestão de dependências é crítica.

Desacoplamento com Outras Ferramentas

Em alguns cenários, integrar o Dotenv com certas ferramentas ou serviços pode exigir configurações adicionais ou scripts personalizados, o que pode complicar o processo de desenvolvimento ou implantação.

Desempenho

Em sistemas de alta carga ou aplicações onde cada milissegundo conta, ler variáveis de ambiente de um arquivo pode introduzir uma sobrecarga mínima em comparação com outras formas mais eficientes de gerenciamento de configurações.

Embora o Dotenv ofereça uma maneira conveniente e segura de gerenciar variáveis de ambiente em projetos Python, é essencial avaliar cuidadosamente as necessidades e requisitos específicos do seu projeto. Em alguns cenários, outras abordagens ou ferramentas podem ser mais adequadas para garantir a segurança, eficiência e escalabilidade da sua aplicação.

Como usar Terraform + Localstack (com Docker)

Rafael Rotiroti — Fri, 17 Mar 2023 21:03:34 +0000

Vou separar esse artigo em 4 partes: motivação, teoria, prática, conclusão.

A intenção é ser um conteúdo leve, introdutório e nada de terno e gravata, que atenda desde de pessoas iniciantes e até mesmo mais experientes.

Estou voltando a escrever agora e pretendo voltar a produzir esse tipo de conteúdo ao longo desse ano. Sugestões e feedback são muito bem vindos!

Motivação

No fim do ano passado eu estava um pouco incomodado com o fato de saber apenas sobre o Terraform teoricamente... queria aprender e ter a capacidade de usar diariamente de forma mais autonoma, só que eu queria estudar com calma, fazer uma aplicação prática para válidar o conhecimento e etc.

Em Janeiro tirei uns dias de férias para descansar, fui viajar e quando voltei tinha uma semana livre, tempo perfeito para se atualizar e colocar minhas ideias em dia.

Terraform foi o escolhido da vez!

Teoria

Como vamos utilizar Terraform, Docker e Localstack vou fazer um pequeno resumo de cada um.

O Terraform é uma tecnologia IaaC (Infrastructure as a Code ou Infraestrutura como código, como prefirir.), permite que você provisione sua infraestura em nuvem através de código, numa estrutura bem familiar ao JSON

O Docker é uma plataforma que faz a criação de administração de containers, ou seja, permite que você isole e esteja preparado para fazer deploy do seu ambiente para nuvem.

O Localstack é uma ferramenta que permite que você desenvolva e teste suas aplicações localmente, ou seja, permite que você utilize e simule tecnologias como SNS, Lambda, SQS, Dynamo e etc no seu ambiente local.

A ideia é basicamente usar o Terraform para provisionar a infraestrutura dentro da minha máquina local, para isso utilizei o Localstack que simula toda minha infraestrutura da AWS dentro dos containeres do Docker.

Prática

Presumo que o Docker, Terraform e AWS CLI estejam configurados e instalados em sua máquina e então podemos iniciar a configuração do Localstack.

Criaremos o arquivo docker-compose.yml com a seguinte instrução:

version: "3.8"

services:
  localstack:
    image: localstack/localstack:1.3.1
    environment: 
      - AWS_DEFAULT_REGION=sa-east-1
      - AWS_ACCESS_KEY_ID=teste
      - AWS_SECRET_ACCESS_KEY=teste
      - EDGE_PORT=4566
      - DATA_DIR=${DATA_DIR-}
      - HOST_TMP_FOLDER=${TMPDIR:-/tmp/}localstack
      - DOCKER_HOST=unix:///var/run/docker.sock
    ports:
      - '4566-4587:4566-4587'
    volumes:
      - localstack-data:/tmp/localstack
      - "/var/run/docker.sock:/var/run/docker.sock"
    networks:
      - dev_to

volumes:
  localstack-data:
    name: localstack-data

networks:
  dev_to:
    name: dev_to

De forma resumida, estamos pedindo para o Docker criar a partir da imagem Localstack(1.3.1) um container. Detalhe na EDGE_PORT=4566 que falarei mais adiante sobre ela!

Com o comando docker compose up -d o Docker vai criar e subir o container na sua máquina local e prover todos os recursos que o Localstack dispõe.

Rode o comando docker ps e veja se obtem um resultado parecido:

Com nosso container no ar e com o Localstack provisionado já podemos partir para o que interessa: Terraform!

No meio do caminho acabei recebendo uma dica de um amigo sobre o TFLocal que foi muito útil, pois ao utilizar o Terraform, precisamos apontar pro ambiente local e o TFLocal foi desenvolvido justamente para o cenário com Localstack.

Para instalar, basta ter o Python e rodar pip install terraform-local

Com isso, vamos escrever nosso arquivo main.tf

provider "aws" {
  region                     = "sa-east-1"
  access_key                 = "teste"
  secret_key                 = "teste"
  skip_credentials_validation = true
  skip_requesting_account_id = true
  skip_metadata_api_check    = true
}


resource "aws_dynamodb_table" "basic-dynamodb-table" {
  name           = "GameScores"
  billing_mode   = "PROVISIONED"
  read_capacity  = 20
  write_capacity = 20
  hash_key       = "UserId"
  range_key      = "GameTitle"

  attribute {
    name = "UserId"
    type = "S"
  }

  attribute {
    name = "GameTitle"
    type = "S"
  }

  attribute {
    name = "TopScore"
    type = "N"
  }

  ttl {
    attribute_name = "TimeToExist"
    enabled        = false
  }

  global_secondary_index {
    name               = "GameTitleIndex"
    hash_key           = "GameTitle"
    range_key          = "TopScore"
    write_capacity     = 10
    read_capacity      = 10
    projection_type    = "INCLUDE"
    non_key_attributes = ["UserId"]
  }

  tags = {
    Name        = "dynamodb-table-1"
    Environment = "production"
  }
}

O arquivo main.tf é responsável por entender qual será o Provider(AWS, GCP, Azure) a ser utilizado e quais serviços serão criados, no exemplo acima eu quis utilizar o mesmo exemplo no site do Terraform que é criar uma tabela no DynamoDB.

Com o arquivo finalizado, podemos iniciar os comandos que vão realmente criar tudo lá dentro para nós, então abra seu terminal e digite: tflocal init

O comando tflocal init faz exatamente o mesmo que o terraform init faz, inicia a configuração do terraform de acordo com o que temos de instrução no main.tf

Em seguida, tflocal plan. Que por sua vez, vai carregar as suas configurações e te mostrar o que tem para ser feito como planejado.

E por final, tflocal apply -auto-approve, esse comando Apply realmente vai fazer a criação (nesse caso DynamoDB) dos serviços que foram planejados e a flag -auto-approve faz com que não haja a necessidade de confirmar com um "yes" na linha de comando.

Pronto, temos tudo criado e a mensagem que apareceu no terminal deve ter sido algo assim:

Para ver se sua table criou, basta rodar aws dynamodb list-tables --endpoint-url http://localhost:4566:

A partir daqui, pode inserir registros na tabela e até mesmo usar o NoSQL Workbench para ter uma GUI de visualização.

Lembra que eu falei sobre o a EDGE_PORT=4566 ?

Veja que eu utilizei ela na minha consulta via CLI, ou seja todos os comandos que eu for fazer de consulta ou apontamentos via código localmente eu devo fazer na porta 4566, pois o localstack está roteando internamente e inteligentemente para os serviços solicitados. Se eu fosse consultar um SQS ou SNS eu apontaria para essa mesma porta 4566 e etc. Obviamente é algo configurável, pode ser utilizado as portas que consta nas docs do Localstack mas eu acho que é algo facilita nossa vida em meio tantas POCs (Prove of concept) que fazemos por ai.

Conclusão

Na minha opnião, desenvolver e testar local é melhor forma de você desenvolver antes de subir para um ambiente de DEV. Por ser um ambiente controlado as ferramentas como Docker, Localstack, Terraform fazem com que tenhamos um ganho absurdo de produtividade e testabilidade.

Além de conseguir testar muitas features sem gastar $ é uma ótima forma de válidar e testar as coisas!

Eu recomendo fortemente combinar essas ferramentas para o uso no dia a dia, fazendo com que nossas entregas além de validadas sejam mais consistentes.

O amigo que mencionei é o Renato Rodrigues, ele que deu a dica de usar o tflocal para iniciar meus estudos com o Terraform usando Localstack. Fica aqui meu agradecimento!

Links que utilizei de inspiração:

How run & use DynamoDB locally

Rafael Rotiroti — Wed, 19 Oct 2022 16:58:21 +0000

This post intent to be simple and direct.

We are going to run DynamoDB locally and connect with him using NoSQL Workbench.

Before we start, check if you have Docker running on your machine. Else not, install here

Choose an folder or create a new one, inside this folder create a file docker-compose.yml:

version: '3.8'
services:
  dynamodb-local:
    command: "-jar DynamoDBLocal.jar -sharedDb -dbPath ./data"
    image: "amazon/dynamodb-local:latest"
    container_name: dynamodb-local
    ports:
      - "8000:8000"
    volumes:
      - "./docker/dynamodb:/home/dynamodblocal/data"
    working_dir: /home/dynamodblocal

In your terminal, inside the folder you created the file run following command:
docker-compose up

If everything is well, this should be the result of your terminal:

Lets connect with DynamoDB using NoSQL Workbench.

Download and install using AWS NoSQL Workbench

Open the NoSQL Workbench Software.

Choose Amazon DynamoDB:

Click in Operation Builder and Add Connection:

Setup your connection:

And everything should be okay if you see this screen:

Hope this article helped you.

DEV Community: Rafael Rotiroti

Como Limitar e Proteger suas APIs com Rate Limit?

Por que o Rate Limiting é importante?

Onde o Rate Limiting é utilizado?

Hands on!

Implementando Rate Limiting no FastAPI com Redis

Supondo que já possua o FastApi up & running:

Vamos criar a classe RateLimiter:

Configurando a aplicação (normalmente no seu main.py ou app.py):

Criando o Middleware

Conclusão

Simple and Functional PHP Environment Setup with Windows

So let's get started.

Starting Docker Containers

Rodando Modelos LLM Localmente com Ollama

Utilizando Dotenv para Gerenciamento de Variáveis de Ambiente e Alembic

Introdução

O que é Dotenv?

Vantagens ao usar .env

Isolamento e Segurança

Portabilidade

Facilidade de Configuração

Hands On!

Configure o ambiente

Configurando o Alembic

Mas nem tudo são flores...

Complexidade em Ambientes Distribuídos

Risco de Exposição

Dependência Externa

Desacoplamento com Outras Ferramentas

Desempenho

Como usar Terraform + Localstack (com Docker)

Motivação

Teoria

Prática

Conclusão

How run & use DynamoDB locally

Vantagens ao usar `.env`