Passo 1: Preparando o Servidor

Acesse seu servidor como administrador (root):

sudo su -

Atualize o sistema operacional para garantir que tudo está atualizado e compatível:

apt-get update -y && apt-get upgrade -y && apt-get dist-upgrade -y

Passo 2: Baixando o Script de Configuração

Utilizaremos um script para configurar automaticamente a VPN. Baixe o script:

wget https://get.vpnsetup.net -O vpn.sh

Antes de executá-lo, abra o script para editar as configurações básicas:

vi vpn.sh

Edite as seguintes variáveis no script:

• Adicione a chave pré-compartilhada (PSK).
• Configure o nome do usuário principal e sua senha.

Depois de configurar, salve e saia do editor (no vi, digite :wq e pressione Enter).

Passo 3: Executando o Script

Com as configurações prontas, execute o script para configurar a VPN:

sh vpn.sh

Esse script configurará os serviços necessários, como o IPsec e o L2TP, além de ajustar as permissões.

Passo 4: Adicionando Usuários Adicionais

Se você precisar criar novos usuários para acessar a VPN, use o seguinte comando:

addvpnuser.sh 'usuario01' 'senha01'

Substitua 'usuario01' e 'senha01' pelos dados do novo usuário.

Passo 5: Liberando Portas no Firewall

Certifique-se de que as portas necessárias para a VPN estão abertas no firewall. As portas que precisam estar liberadas são:

• Porta 500 UDP (IKEv1/IKEv2)
• Porta 4500 UDP (NAT-T)

Se você utiliza o ufw, execute os comandos abaixo:

ufw allow 500/udp
ufw allow 4500/udp
ufw reload

Caso utilize outra ferramenta de firewall, ajuste as configurações conforme necessário.

Dicas Finais

• Após a configuração, você pode conectar dispositivos Windows, macOS, Android ou iOS à VPN utilizando o IP do servidor, a chave pré-compartilhada (PSK) e as credenciais de usuário criadas.
• Teste a conexão para garantir que a VPN está funcionando corretamente.

Conclusão

Com esses passos, você terá uma VPN L2TP funcionando de forma eficiente e segura no Ubuntu Server. Isso pode ser útil para acessar recursos remotos, proteger conexões públicas ou até mesmo criar um ambiente de trabalho seguro para sua equipe.

Se você encontrou algum problema ou tem dúvidas, compartilhe nos comentários!

Passo 1: Criar a Função Lambda

1. Nome da Função: CE-Exporter-MySQL
2. Linguagem: Python 3.12

Passo 2: Configurar o Banco de Dados MySQL

Execute os seguintes comandos no seu servidor MySQL para criar o banco de dados e a tabela necessária:

CREATE DATABASE IF NOT EXISTS ResourceCosts;
USE ResourceCosts;

CREATE TABLE costs (
  id int AUTO_INCREMENT PRIMARY KEY,
  account_id varchar(20),
  region varchar(50),
  service varchar(50),
  amount decimal(10,2),
  currency_unit varchar(10),
  start_time datetime,
  end_time datetime
);

ALTER TABLE costs
  ADD KEY idx_costs_account_region_service (account_id, region, service);

Passo 3: Criar a Pasta do Código do Lambda

1. Diretório Local: Crie um diretório local para armazenar o código da Lambda.
2. Dependências: Crie um arquivo requirements.txt com o seguinte conteúdo:

pymysql
boto3

Passo 4: Instalar Dependências

No terminal, execute o comando abaixo para instalar as dependências no diretório local:

pip3 install -r requirements.txt -t .

Passo 5: Adicionar o Código Fonte

Crie um arquivo chamado lambda_function.py no mesmo diretório e adicione o seguinte código:

import boto3
import pymysql
import os
import datetime

# Configurações MySQL
MYSQL_DB = os.getenv('MYSQL_DB')
MYSQL_HOST = os.getenv('MYSQL_HOST')
MYSQL_PASSWORD = os.getenv('MYSQL_PASSWORD')
MYSQL_PORT = int(os.getenv('MYSQL_PORT'))
MYSQL_USER = os.getenv('MYSQL_USER')

# Classe para manipulação de dados do Cost Explorer e MySQL
class CostExplorerToMySQL:
    def __init__(self):
        self.ce_client = boto3.client('ce')
        self.sts_client = boto3.client('sts')
        self.conn = pymysql.connect(host=MYSQL_HOST,
                                    user=MYSQL_USER,
                                    password=MYSQL_PASSWORD,
                                    db=MYSQL_DB,
                                    port=MYSQL_PORT)
        self.account_id = self.get_account_id()

    def get_account_id(self):
        response = self.sts_client.get_caller_identity()
        return response['Account']

    def fetch_cost_data(self, start_date, end_date):
        results = []
        response = self.ce_client.get_cost_and_usage(
            TimePeriod={'Start': start_date, 'End': end_date},
            Granularity='DAILY',
            Metrics=['UnblendedCost'],
            GroupBy=[
                {'Type': 'DIMENSION', 'Key': 'REGION'},
                {'Type': 'DIMENSION', 'Key': 'SERVICE'}
            ]
        )
        results.extend(response['ResultsByTime'])
        while 'nextToken' in response:
            nextToken = response['nextToken']
            response = self.ce_client.get_cost_and_usage(
                TimePeriod={'Start': start_date, 'End': end_date},
                Granularity='DAILY',
                Metrics=['UnblendedCost'],
                GroupBy=[
                    {'Type': 'DIMENSION', 'Key': 'REGION'},
                    {'Type': 'DIMENSION', 'Key': 'SERVICE'}
                ],
                NextPageToken=nextToken
            )
            results.extend(response['ResultsByTime'])
        return results

    def insert_cost_data(self, data):
        cursor = self.conn.cursor()
        insert_query = """
            INSERT INTO costs (account_id, region, service, amount, currency_unit, start_time, end_time)
            VALUES (%s, %s, %s, %s, %s, %s, %s)
        """
        cursor.executemany(insert_query, data)
        self.conn.commit()

    def process_and_store_data(self, start_date, end_date):
        raw_data = self.fetch_cost_data(start_date, end_date)
        processed_data = []
        for result in raw_data:
            start_time = result['TimePeriod']['Start'] + " 00:00:00"
            end_time = result['TimePeriod']['End'] + " 23:59:59"
            for group in result['Groups']:
                region = group['Keys'][0]
                service = group['Keys'][1]
                amount = float(group['Metrics']['UnblendedCost']['Amount'])
                currency_unit = group['Metrics']['UnblendedCost']['Unit']
                processed_data.append((self.account_id, region, service, amount, currency_unit, start_time, end_time))
        self.insert_cost_data(processed_data)

    def close(self):
        self.conn.close()

def lambda_handler(event, context):
    explorer_to_mysql = CostExplorerToMySQL()
    ontem = datetime.datetime.utcnow() - datetime.timedelta(days=1)
    hoje = datetime.datetime.utcnow()
    start_date = ontem.strftime('%Y-%m-%d')
    end_date = hoje.strftime('%Y-%m-%d')
    explorer_to_mysql.process_and_store_data(start_date, end_date)
    explorer_to_mysql.close()
    return "Report Generated"

Passo 6: Empacotar e Enviar para a AWS

Compacte o conteúdo do diretório em um arquivo ZIP e envie para a função Lambda na AWS:

zip -r aws-ce-exporter-mysql.zip .
aws lambda update-function-code --function-name CE-Exporter-MySQL --zip-file fileb://aws-ce-exporter-mysql.zip
rm -rf aws-ce-exporter-mysql.zip

Passo 7: Criar a Política de IAM

Crie uma política de IAM no console da AWS com o seguinte JSON para permitir as ações ce:GetCostAndUsage e tag:GetResources:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "ce:GetCostAndUsage",
                "tag:GetResources"
            ],
            "Resource": "*"
        }
    ]
}

Passo 8: Anexar a Política à Role do Lambda

No console da AWS, vá até a função Lambda CE-Exporter-MySQL, clique em “Configurações de permissão” e anexe a política criada anteriormente à função.

Passo 9: Configurar Variáveis de Ambiente

No console do AWS Lambda, vá para as configurações da sua função Lambda e adicione as seguintes variáveis de ambiente:

• MYSQL_DB: Nome do banco de dados MySQL (ex.: ResourceCosts)
• MYSQL_HOST: Endereço do host do banco de dados MySQL
• MYSQL_PASSWORD: Senha do usuário do banco de dados MySQL
• MYSQL_PORT: Porta do banco de dados MySQL (geralmente 3306)
• MYSQL_USER: Usuário do banco de dados MySQL

Passo 10: Ajustar o Tempo de Execução Máximo da Lambda

No Console da AWS, navegue até a função Lambda CE-Exporter-MySQL. Clique na guia Configuration e, em seguida, em General configuration. Clique em Edit para ajustar o tempo de execução máximo. Defina o Timeout para 15 segundos e clique em Save.

Passo 11: Criar o EventBridge para Disparar a Lambda

No Console da AWS, navegue até Amazon EventBridge. Clique em Create rule para criar uma nova regra. Dê um nome à sua regra, como Ce-Exporter-MySQL-EB-Rule, e selecione Rule type como Event pattern. Na seção Event pattern, selecione Scheduled event e insira a expressão de cronograma: cron(0 0 * * ? *) para agendar a execução da Lambda diariamente à 00:00 UTC. Clique em Next.

Conclusão

Com esses passos, a função Lambda CE-Exporter-MySQL estará configurada para executar diariamente, obter os custos do AWS Cost Explorer e inserir esses dados no banco de dados MySQL. Certifique-se de configurar corretamente as variáveis de ambiente para que a função Lambda possa conectar ao banco de dados

Como Funcionam Variáveis no Terraform

Input Variables

As variáveis de entrada (input variables) permitem a parametrização do código Terraform, tornando-o mais flexível. Aqui estão os principais argumentos usados em input variables:

• default: Valor padrão da variável.
• type: Tipo da variável.
• description: Descrição da variável.
• validation: Regras de validação.
• sensitive: Indica se a variável deve ser tratada como sensível.
• nullable: Indica se a variável pode ser nula.

Tipos Suportados

• Simples: string, number, bool
• Complexos: list(<tipo>), set(<tipo>), map(<tipo>), object({nome_de_atributo = <tipo>}), tuple([<tipo>, ...])

Exemplo de Definição de Variáveis

// variables.tf
variable "ami_id" {
  description = "ID da AMI para a instância"
  type        = string
  default     = "ami-12345678"
}

variable "instance_type" {
  description = "Tipo da instância"
  type        = string
  default     = "t2.micro"
}

variable "instance_name" {
  description = "Nome da instância"
  type        = string
  default     = "MinhaInstancia"
}

Utilizando Variáveis no Código

// main.tf
provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "example" {
  ami           = var.ami_id
  instance_type = var.instance_type
  tags = {
    Name = var.instance_name
  }
}

Outputs no Terraform

Outputs são usados para expor informações sobre a infraestrutura provisionada pelo Terraform, facilitando o compartilhamento de dados entre diferentes partes do código ou mesmo com outras ferramentas.

Definindo Outputs

// outputs.tf
output "instance_id" {
  description = "ID da instância EC2"
  value       = aws_instance.example.id
}

output "instance_public_ip" {
  description = "Endereço IP público da instância EC2"
  value       = aws_instance.example.public_ip
  sensitive   = true
}

Utilizando Outputs

Os outputs definidos podem ser acessados utilizando o comando terraform output:

terraform output instance_id
terraform output -raw instance_public_ip

Exemplos de Configuração e Uso

Arquivo variables.tf

variable "location" {
  description = "Localização dos recursos"
  type        = string
  default     = "us-east-1"
}

variable "account_tier" {
  description = "Nível da conta de armazenamento"
  type        = string
  default     = "Standard"
}

variable "account_replication_type" {
  description = "Tipo de replicação da conta de armazenamento"
  type        = string
  default     = "LRS"
}

Arquivo main.tf

provider "azurerm" {
  features {}
}

resource "azurerm_resource_group" "rg_storage" {
  name     = "myResourceGroup"
  location = var.location
}

resource "azurerm_storage_account" "storage_account" {
  name                     = "mystorageaccount"
  resource_group_name      = azurerm_resource_group.rg_storage.name
  location                 = var.location
  account_tier             = var.account_tier
  account_replication_type = var.account_replication_type
}

Arquivo outputs.tf

output "storage_account_id" {
  description = "ID da Storage Account criada na Azure"
  value       = azurerm_storage_account.storage_account.id
}

output "sa_primary_access_key" {
  description = "Primary Access Key da Storage Account criada na Azure"
  value       = azurerm_storage_account.storage_account.primary_access_key
  sensitive   = true
}

Benefícios dos Outputs

• Compartilhamento de Informações: Permitem compartilhar dados entre diferentes partes do código ou módulos.
• Integração: Facilitam a integração com outras ferramentas e scripts.
• Segurança: A utilização do atributo sensitive ajuda a proteger informações confidenciais.

Com esses conceitos e exemplos, você estará pronto para utilizar variáveis e outputs no Terraform de forma eficiente, tornando seu código mais modular, seguro e fácil de manter.

O que é o Terraform?

Terraform é uma ferramenta de código aberto que permite definir, provisionar e gerenciar recursos de infraestrutura em nuvens públicas e privadas. Com o Terraform, é possível automatizar a criação, atualização e versionamento da infraestrutura, garantindo consistência e rastreabilidade.

Vantagens do Terraform

• Automação: Simplifica o provisionamento de infraestrutura.
• Consistência: Assegura a criação consistente de infraestrutura.
• Reutilização: Permite reutilizar o código para diferentes ambientes.
• Versionamento: Facilita o rollback em caso de problemas.
• Multi-cloud: Suporta múltiplos provedores de nuvem, como AWS, Azure e Google Cloud.

Instalando o Terraform com ASDF

Instalar o Terraform usando ASDF é altamente vantajoso porque permite trabalhar com múltiplas versões do Terraform de forma eficiente. Isso significa que você pode gerenciar diferentes projetos e contas usando versões distintas do Terraform sem a necessidade de desinstalar e reinstalar a ferramenta. Por exemplo, você pode implantar um projeto em uma conta com uma versão específica do Terraform e, ao mesmo tempo, usar uma versão mais recente para outra conta, garantindo flexibilidade e compatibilidade sem complicações.

Para instalar o Terraform usando o ASDF, siga estes passos:

1. Instale o ASDF: Siga as instruções no repositório oficial do ASDF.
2. Adicione o Plugin Terraform: asdf plugin add terraform https://github.com/asdf-community/asdf-hashicorp.git
3. Instale a Versão Desejada do Terraform: asdf install terraform <versão_desejada>
4. Defina a Versão Global (opcional): asdf global terraform <versão_desejada>
5. Configure o Projeto: No diretório do seu projeto, crie um arquivo .tool-versions e adicione a versão do Terraform que você quer usar: terraform <versão_desejada>

Estrutura de Arquivos do Terraform

• main.tf: Define os recursos principais.
• variables.tf: Define variáveis usadas no código.
• outputs.tf: Define saídas exibidas após a aplicação do plano.
• provider.tf: Define os provedores utilizados no projeto.
• terraform.tfstate: Armazena o estado atual da infraestrutura.
• terraform.tfstate.backup: Backup do estado anterior.

Comandos Básicos do Terraform

Terraform Init: Inicializa um novo código Terraform ou atualiza uma configuração existente.

terraform init

Terraform Fmt: Formata automaticamente o código Terraform.

terraform fmt

Terraform Validate: Verifica se a configuração do código é válida.

terraform validate

Terraform Plan: Gera um plano de execução para a infraestrutura.

terraform plan

Terraform Apply: Aplica as mudanças definidas no plano.

terraform apply

Terraform Destroy: Destroi a infraestrutura gerenciada pelo Terraform.

terraform destroy

Exemplo de Comando Completo

terraform init
terraform fmt
terraform validate
terraform plan -out plano.out
terraform apply plano.out
terraform destroy

Seguindo estes passos e utilizando estes comandos, você poderá gerenciar sua infraestrutura de forma eficiente e segura com o Terraform. Automatize suas tarefas, mantenha a consistência e garanta a rastreabilidade das mudanças em seus recursos de nuvem.

Para mais detalhes, consulte a documentação oficial do Terraform e mantenha-se atualizado com as melhores práticas em infraestrutura como código.

Hospedar um site estático na AWS usando serviços como o Amazon S3 e o Amazon CloudFront é uma maneira eficiente e escalável de disponibilizar seu conteúdo na web. Neste guia passo a passo, aprenderemos como hospedar um site estático usando uma aplicação React como exemplo, mas o processo é semelhante para outros frameworks como Angular e Vue. O foco principal é garantir que o resultado final do build seja composto por arquivos HTML, CSS, JS e assets.

Passo 1: Preparação do Projeto React:

Crie um novo projeto React com o seguinte comando:

npx create-react-app nome-do-seu-projeto

Agora navegue para o diretório do projeto:

cd nome-do-seu-projeto

Desenvolva o seu site estático normalmente, adicionando componentes, estilos e conteúdo.

Passo 2: Build da Aplicação:

Quando estiver satisfeito com o desenvolvimento, crie o build otimizado da aplicação React:

npm run build

Isso criará uma pasta chamada build no diretório do projeto, contendo os arquivos otimizados para produção.

Passo 3: Configurando o Amazon S3:

1. Acesse o Console de Gerenciamento da AWS e navegue até o serviço S3.

2. Crie um novo bucket, escolhendo um nome único e uma região.

3. Na seção “Propriedades”, habilite a opção “Hospedagem de site estático” e defina o arquivo index.html como documento de índice.

Passo 4: Carregando Arquivos para o Amazon S3:

Agora é hora de transferir os arquivos do seu site estático para o Amazon S3. Você tem duas opções para fazer isso: via terminal ou pela interface do Console do S3.

Opção 1: Via Terminal (Recomendado para Automatização):

Se você está familiarizado com o terminal e deseja automatizar o processo, use o seguinte comando para sincronizar a pasta build com o seu bucket S3:

aws s3 sync --recursive build/* s3://nome-do-seu-bucket

Opção 2: Pela Interface do Console do S3 (Simples e Visual):

Se preferir uma abordagem mais visual e direta, siga os passos abaixo:

1. Acesse o Console de Gerenciamento da AWS e vá para o serviço CloudFront.
2. Clique no nome do seu bucket para acessar a lista de objetos.
3. No canto superior direito, clique em “Fazer upload” e selecione os arquivos da pasta build para carregar.
4. Ou, se preferir, você pode arrastar e soltar os arquivos da pasta build diretamente na interface do navegador.

Independentemente do método escolhido, os arquivos do seu site serão carregados para o Amazon S3, preparando-se para serem distribuídos pelo CloudFront.

Passo 5: Configurando o Amazon CloudFront:

1. Acesse o Console de Gerenciamento da AWS e navegue até o serviço CloudFront.

2. Crie uma nova distribuição. Na seção “Origem”, selecione o bucket S3 que contém os arquivos do seu site estático.

3. Configure as seguintes opções:

• Allowed HTTP methods: Defina os métodos HTTP permitidos para acessar seus arquivos. Geralmente, é seguro habilitar todos os métodos.

• Viewer protocol policy: Escolha como deseja que o CloudFront lide com as solicitações dos usuários. A opção “Redirecionar HTTP para HTTPS” é uma escolha segura, garantindo que todas as conexões sejam criptografadas.

• Custom SSL certificate – optional: Nesta seção, você pode optar por gerar um certificado SSL personalizado para seu domínio. Isso é importante para habilitar o acesso seguro por HTTPS. Clique em “Request or Import a Certificate with ACM” para gerar um novo certificado usando o AWS Certificate Manager.

4. Na seção “Configurações de Domínio Alternativo (CNAMEs)”, você pode adicionar os domínios personalizados que deseja associar à sua distribuição CloudFront.

6. Complete o processo de criação da distribuição.

7. Aguarde até que a distribuição seja provisionada. Quando estiver pronta, você verá o status “Deployed” na lista de distribuições do CloudFront.

Com o Amazon CloudFront configurado, seus arquivos serão distribuídos globalmente e as configurações escolhidas garantirão um desempenho otimizado e uma experiência segura para os usuários do seu site estático.

Passo 6: Configuração de DNS:

1. Acesse o provedor de domínio onde você comprou o domínio (ex: Route 53, GoDaddy).
2. Adicione registros DNS do tipo CNAME ou Alias apontando para o domínio da sua distribuição CloudFront.
3. Aguarde a propagação DNS, que pode levar algumas horas.

Conclusão:

Parabéns! Agora seu site estático React (ou de qualquer outro framework) está hospedado na AWS usando o Amazon S3 e o CloudFront. Você aprendeu como preparar o projeto, criar o build, configurar o S3 para hospedagem, configurar o CloudFront para distribuição global e como associar um domínio personalizado ao seu site. Com esses passos, seu site estará disponível de maneira rápida e escalável para os visitantes. Lembre-se de que esse processo também é aplicável a outras tecnologias e frameworks, contanto que o resultado final seja composto por arquivos HTML, CSS e assets.

Leia nossos novos posts no blog! Fique por dentro das últimas novidades e dicas no mundo da programação. Visite o blog em www.manualdoprogramador.com e aproveite todo o conteúdo atualizado sobre programação e desenvolvimento de software

Aproveite e confira os nossos posts no Instagram @blogmdp.

A flexibilidade é um dos principais pontos fortes da computação em nuvem. Ao adotar essa abordagem, as empresas podem acessar seus recursos de computação a qualquer momento e de qualquer lugar do mundo. Isso significa que você não está mais limitado à infraestrutura física presente em seu escritório. Com a nuvem, você pode expandir ou reduzir seus recursos conforme necessário, sem a necessidade de investir em hardware adicional. Essa flexibilidade oferece uma vantagem competitiva significativa, permitindo que você se adapte rapidamente às mudanças do mercado e às demandas do seu negócio.

Outro benefício essencial da computação em nuvem é a escalabilidade. Com a capacidade de aumentar rapidamente a capacidade de processamento e armazenamento, você não precisa mais se preocupar com limitações de recursos. Se o seu negócio está crescendo ou se você precisa lidar com picos de demanda sazonais, a nuvem pode fornecer os recursos necessários sem atrasos ou altos custos. Isso permite que você atenda aos requisitos do seu negócio de forma ágil, garantindo a satisfação dos clientes e evitando a perda de oportunidades de crescimento.

A economia de custos também é uma vantagem inegável da computação em nuvem. Ao adotar essa tecnologia, você paga apenas pelos recursos que utiliza. Em vez de investir grandes quantias de dinheiro em hardware e servidores, você pode direcionar seus recursos financeiros para outras áreas estratégicas do seu negócio. Além disso, a manutenção e atualização dos sistemas são responsabilidades do provedor de nuvem, o que reduz ainda mais os custos operacionais.

Por fim, a segurança é uma preocupação primordial para qualquer empresa. A computação em nuvem oferece uma abordagem robusta para proteger seus dados e sistemas. Os provedores de nuvem implementam protocolos de segurança avançados e mantêm seus servidores altamente protegidos contra ameaças externas. Além disso, a redundância e a replicação de dados na nuvem garantem a recuperação rápida e confiável em caso de falhas ou desastres. Isso significa que você pode operar com tranquilidade, sabendo que seus dados estão protegidos e acessíveis quando necessário.

Em resumo, a computação em nuvem oferece uma série de benefícios essenciais para as empresas. A flexibilidade, escalabilidade, economia de custos e segurança são apenas algumas das vantagens que podem impulsionar seu negócio para um novo nível de eficiência e sucesso. Se você ainda não adotou a computação em nuvem, é hora de considerar essa tecnologia e explorar as possibilidades que ela oferece. Esteja preparado para aproveitar todas as oportunidades que a nuvem proporciona e fortaleça a base do seu negócio para um futuro promissor.