Precificando AWS

TCO - Total Cost of Ownership: Custo total de propriedade:

Modelos de precificação aws:

Ofertas Grátis AWS (3 niveis):

Exemplos de cobrança aws:

 

AWS Framework

AWS é a líder em Cloud:

Serviços em oferta da AWS:

Estrutura Bem-Arquitetada da AWS:

Ferramenta de Boa-Arquitetura da AWS:

Responsabilidade compartilhada da AWS:

Planejamento para falhas:

Fazendo o Deploy (a implantação) na nuvem...

Implantanção na nuvem:

Modelos de Computação em Nuvem:

Modelos de deploy (implantação) de computação em Nuvem:

Iniciando minha jornada na AWS

Após realizar o cadastro e logar na AWS Educate: iniciei meus estudos e criei uma conta na AWS Web Services para entender melhor o primeiro curso que foi o: "introduction to AWS Management Console" dentro da plataforma. Um detalhe é que após criar uma conta na "aws web services" que é necessário ter um cartão de crédito, automaticamente entramos em 3 categorias de produtos para testarmos: 

• Os totalmente grátis
• Os grátis por 12 meses (após a criação da conta)
• Grátis por periodo menor de tempo (apos o primeiro uso do produto ou serviço)

Agora estou realizando o curso: "Introduction to Cloud 101" que é bem maior e ao final existe a possibilidade de recebimento de um certificado badge.

Algumas informações interessantes adquiridas no curso:

6 benefícios da "computação em nuvem"/ cloud computing (aws educate):

1. Trocar gastos antecipados por gastos variáveis: gastos antecipados se referem a centro de dados (data centers), servidores físicos, e outros recursos que você iria precisar investir antes de usá-los. Gasto variável significa que você paga apenas pelos recursos computacionais que você consome. Você não precisa investir pesadamente em centro de dados (data centers) e servidores antes de saber como você irá usá-los

2. Pare de gastar dinheiro para "rodar" (run - tradução liberal) e manter centros de dados (data centers): Computação em data centers geralmente requerem que você gaste mais dinheiro e tempo administrando infraestrutura e servidores. Um benefício da computação em nuvem é a habilidade de focar menos nessas tarefas e mais nas suas aplicações/aplicativos e clientes.

3.Pare de adivinhar a capacidade: com a computação em nuvem, vocẽ não precisa predizer quanto de capacidade de infraestrutura vai precisar antes de fazer o deploy (implantação) de uma aplicação/aplicativo. Por exemplo, você pode lançar exemplos Amazon EC2 quando preciso, e pagar somente pelo tempo de computação que você usa. Vocẽ também pode aumentar ou diminuir a escala em resposta à demana.

4. Beneficie-se de enormes economias de escala: usando a computação em nuvem você pode alcançar um custo variavél menor do que você pode ter por você mesmo. Porque o uso de centenas de milhares de clientes podem agregar na nuvem, provedores como a AWS podem obter maiores economias de escala.

5. Aumento de velocidade e agilidade: a flexibilidade da computação de nuvem torna fácil o deselvovilmento e o deploy (implantação) de aplicações/ aplicativos. Essa flexibilidade te dá mais tempo para experimentar e inovar. Quando computa em data centers, pode levar semanas para obter novos recursos que você precisa. Pela comparação você pode usar a nuvem para acessar novos recursos em minutos.

6. Seja global em minutos: você pode usar a pegada da nuvem AWS Cloud para fazer o deploy de aplicações/apps para clientes do munto todo rapidamente, enquanto fornece baixa latencia. Portantom mesmo se você está localizado em uma diferente parte do mundo, seus clientes podem acessar seus apps com minimos atrasos. 

Faz sentido? Qual a sua opinião?

Entendendo Git e GitHub de uma vez por todas (tutorial com imagens)!

Este é um tutorial para quem quer aprender (ou relembrar) rapidamente GIT (e GITHUB), talvez já tenha tentado aprender e não conseguiu, este pode ser o tutorial certo!

*inicialmente a ideia era apenas para ser um tutorial rápido para os outros, acabou se tornando um tutorial de referência para eu mesmo relembrar comandos básicos de git no terminal:

Primeiro você precisa saber se no seu computador e sistema operacional o git já está instalado, basta abrir o terminal e digitar: "git --version" git(espaço)--version

Então o terminal precisa retornar a versão, senão houver basta instalar no site oficial: https://git-scm.com

Após a instalação, execute o comando: git --version (no terminal novamente, para saber a versão do git instalado, se não retornar a versão, reinicie seu computador e tente executar o comando novamente) e feche o terminal.

Feito isso vamos iniciar nosso tutorial prático:

1- Primeiro criar uma pasta no desktop mesmo e chamar de "projetogit:"

2- Dentro da pasta, na aba da pasta "view"clique para: "mostrar arquivos ocultos" para conseguir ver a pasta ".git" que será criada.

3- Novamente dentro da pasta, clique com o botão esquerdo do mouse e "inicie o terminal".

Mas antes:

4- Descubra se o "user.name" do seu git já está configurado, digite no terminal (sem as aspas): "git config --global user.name", se não houver retorno, vocôe precisa configurar, para usar git essas são as 2 configurações básicas: "nome de usuário" e "email", então para adicionar o nome de usuário basta repetir o comando e adicionar o nome: "git config --global user.name Fulano", veja o exemplo na imagem abaixo

5- Descubra se o "user.email" do seu git já está configurado, digite no terminal (sem as aspas): "git config --global user.email", se quiser trocar basta repetir o comando e adicionar o nome: "git config --global user.email fulano@email.com"

Verificando e Iniciando o GIT:

6- No terminal digite: git status que retornará um erro avisando que não há um repositório ou pasta .git.

7- No terminal digite: "git init" para iniciar o git dentro desta pasta, se você ativou a opção de: "ver arquivos ocultos" na pasta então verá a pasta: ".git" o terminal também exibirá um aviso que o repositório foi criado. Você também pode conferir usando o comando: "git status".

Na Branch:

8- Você estará dentro da "branch master" ou "main branch" ou "branch (ramo) principal", para mudar o nome da sua branch use o comando: "git branch -m main" e o nome da branch agora será "main", que é o nome mais utilizado, para verificar utilize novamente o comando: "git status".

Adicionando um arquivo no repositório local:

9- Na pasta crie um: "arquivo1.py", no terminal, execute novamente o comando: "git status" para ver o status, execute o comando: "git add arquivo1.py", execute novamente o comando: "git status" para ver o novo status.

"Commitando":

10- No terminal execute: "git commit -m 'primeiro commit' arquivo1.py"

FIM do tutorial de GIT (por enquanto).

-Inicio do tutorial de GITHUB:

1. No site do github crie sua conta.

2. Crie um novo repositório: "projetogithub", conecte este "repositório remoto do github" com o seu "repositório local". Para isso dentro da pasta "projetogit" abra o terminal e execute o comando (sempre sem as aspas): "git remote add origin https://github.com/(seunomedeusuário)/projetogithub.git". 

Para verificar se deu tudo certo execute: "git remote -v".

Iniciando o envio de arquivos para o Repositório Remoto do GITHUB via conexão HTTPS:

3. Com o terminal aberto "dentro da pasta"(/Desktop/usuário/projetogit$) execute o comando: 

"git push -u origin main" 

que vai pedir seu usuário do github, e senha que deve ser um "token de acesso pessoal", se você ainda não tem um, crie da seguinte maneira abaixo:

Criando um Token de Acesso Pessoal (classic):

4. Clique na foto do seu perfil, no canto superior direito e selecione "settings" depois clique em: "< > Developer settings", depois em: "Tokens (classic)" e por fim em: "Generate new token (classic)", configure a expiração e as permissões para criar o token, após a sua criação, copie o token (guarde para usá-lo depois se precisar novamente) e cole no password requisitado no terminal (para colar no terminal: "Ctrl+Shift+v").

*4.2. Para não precisar ficar digitando sempre o usuário e a senha sempre que tiver de fazer alguma alteração no repositório remoto execute o comando: "git config --global credential.helper store" e assim ele vai armazenar suas credenciais para não precisar digitar novamente usuário e senha (token classic).

4.3. Para saber onde estas informações estão sendo armazenadas, basta executar o comando: "git config --global --show-origin credential.helper" que no meu caso vai estar na pasta: "/home/venelouis/.gitconfig" ao ir na pasta ative a visualização de "arquivos ocultos" lá vai estar também o arquivo: ".git-credentials" que podemos acessar através do próprio terminal utilizando o comando: "cd /home/venelouis/" executar o comando: "ls -a" para listar todos os arquivos e pastas (inclusive os ocultos) e por fim podemos utilizar o comando: "cat .gitconfig" para ver o que está no arquivo: ".gitconfig" e executar também: "cat .git-credentials" e lá vão estar suas credenciais globais e sua senha (seu token classic), ou seja se por questões de segurança precisarmos inibir o acesso podemos mudar a senha ou apenas deletar o arquivo, mas no próprio site do github podemos remover-deletar esse token também.

Verificando o envio do "arquivo1.py" do repositório local para o repositório remoto:

5. visite seu o repositório no criado no github que nomeamos de: "projetogithub".

Git Push, Mandando arquivos do Repositório Local para o Repositório Remoto GitHub:

6. Modifique o "arquivo1.py" no seu computador e salve, após isso no terminal dentro da pasta execute o comando: "git status".

7. Execute: "git add ." para adicionar todas modificações dentro da sua pasta "projetogit".

8. Execute: "git status" novamente para visualizar as modificações.

9. Execute: "git commit -m 'commitando modificação do "arquivo1.py" para o repositório remoto' ".

10. Execute novamente: "git status" para verificar que sua "branch main local" está mais atualizada do que a sua "branch main remota" e para que ambas estejam atualizas igualmente execute finalmente mais uma vez: "git push".

Git Pull, Recebendo arquivos do Repositório Remoto GitHub para o Repositório Local:

11. No repositório do Github altere o seu "arquivo1.py" e faça um "commit".

12. Se você executar o comando "git status" no seu terminal talvez ele exiba a mensagem "your branch is up to date with 'origin/main'." o que é falso pois acabamos de alterar o arquivo1.py no repositório remoto e se verificarmos o "arquivo1.py" no repositório local (pasta: "projetogit") ele continua sem a alteração. 

13. Então com o terminal "aberto na pasta do projeto" execute o comando "git pull", se pedir coloque novamente usuário e senha (token de acesso pessoal (classic) do github), pronto você verá a confirmação no terminal e agora se você abrir no repositório local (pasta "projetogit") o "arquivo1.py" vai ver que foi alterado.

Git Clone:

14. Vamos imaginar que você está em outro computador, e quer modificar o seu código remoto do github no seu computador em um repositório local, para isso você utiliza o comando: "git clone" na pasta desejada, veja como utilizar este comando abaixo: 

15. Então crie uma outra pasta no seu desktop chamada: "NovoComputador" e abra o terminal dentro desta pasta e execute o comando: 

"git clone https://github.com/(seunomedeusuário)/projetogithub.git"

Se precisar coloque novamente usuário e senha (personal token (classic)) e pronto, a pasta "projetogithub" será adicionada no seu "NovoComputador" (pasta) juntamente com o "arquivo1.py" e a pasta oculta: ".git".

15.2. * Apenas como curiosidade, se quizermos clonar apenas uma branch podemos utilizar o comando: 

"git clone -b <branchname> <remote-repo-url>"

Modificando o repositório remoto do GitHub no seu "NovoComputador":

16. Na sua pasta "NovoComputador" modifique o "arquivo1.py" e salve.

17. No terminal execute os comandos: "git add ." para adicionar a alteração ao git.

18. Para verificar utilize o comando: "git status"

19. Depois: "git commit -m 'alteração a partir do NovoComputador'

20. Por fim como é a primeira vez de um que o push está sendo feito deste novo repositório local, ou seja pasta "NovoComputador" precisamos executar o comando no terminal dentro desta pasta: 

"git push -u origin main".

E podemos verificar no repositório remoto (github) a última alteração e o histórico de commits:

Criando Branches (Ramos) no Git/GitHub:

21. Agora novamente dentro da pasta "projetogit" vamos abrir o terminal e executar o comando: "git branch teste".

22. Para verificar as branches existentes no seu repositório basta executar o comando: "git branch", e o terminal vai listar as branches existentes e destacar em qual branch você está.

23. Para entrar na nova branch criada execute no terminal (dentro da pasta desejada em que criou a nova branch) o comando: "git checkout teste" e você vai mudar para a branch "teste".

24. Execute o comando "git branch" para verificar a mudança.

24.2. Para criar uma nova branch e mudar para ela rapidamente basta executar o comando:
"git checkout -b novabranch".

Trabalhando com Branches:

25. Dentro branch "teste2" na pasta "projetogit" crie um novo: "arquivo2.py", execute o comando "git status" para verificar que o arquivo foi criado na branch "teste2".

26. Novamente no terminal dentro da pasta e execute: "git add ."

27. Utilize o comando: "git status" para verificar que a mudança foi adicionada na branch "teste2".

28. Depois execute: "git commit -m 'commit na branch teste2'.

29. Execute o comando: "git checkout main" e veja que na pasta "projetogit" que o "arquivo2.py" parece ter "sumido" da pasta. Para voltar basta executar: "git checkout teste2".

Branches Remotas:

30. Para ver as branches remotas (github) existentes execute no terminal: "git branch -r".

31. Para ver todas as branches: locais e remotas execute: "git branch -a".

Enviando "arquivo2.py" da branch "teste2" para o Repositório Remoto Github:

32. Execute o comando: "git push -u origin teste2"

33. Execute: "git branch -a" para verificar que agora temos 2 branches remotas.

Excluindo Branches

34. Não se pode excluir uma branch dentro dela, portanto vamos criar uma nova branch "teste1" e entrar nela utilizando o comando: "git checkout -b teste1". E utilizando o comando: "git branch" para verificar que saímos da branch "teste".

35. E agora utilizamos o comando: "git branch -D teste". Para conferir que a branch "teste" foi realmente excluida basta executar novamente o comando: "git branch", contudo este comando exclui apenas a branch no repositório local.

36. Para excluir uma branch no repositório remoto, vamos rapidamente criar uma branch com o comando: "git checkout -b teste3" e enviá-la para o repositório remoto utilizando o comando: "git push origin teste3".

37. E por fim vamos excluir essa branch remota utilizamos o comando: "git push -d origin teste3" e exclui-lo da branch local também, entrando na branch "main" com o comando: "git checkout main" e utilizando o comando: "git branch -D teste3". Para verificar basta executar: "git branch -a".

Unindo Branches (Git Merge):

38. Precisamos estar dentro da branch que queremos unir, no caso: "teste1" com a "teste2", portanto no terminal executamos o comando: "git checkout teste2", vamos criar um novo "arquivo3.py", e no terminal executar: "git add ." e 'git commit -m "criação do novo arquivo3.py".' 

39. Este "arquivo3.py" vai aparecer apenas na branch "teste2", se executarmos o comando: "git checkout teste1" veremos que ele não aparece na branch "teste1".

40. Para isso basta que executemos o comando: "git merge teste2" e agora veremos as branches "teste1"

e "teste2" com os mesmos arquivos.

41. Vamos publicar tudo para o repositório remoto do github: "git push". Contudo vai aparecer uma mensagem de erro (se estivermos na branch "teste1"), pois a branch "teste1" ainda não está no repositório remoto como podemos conferir: "git branch -a". 

42. Então vamos enviar a branch "teste1" executando: "git push -u origin teste1" e verificar novamente executando: "git branch -a".

43. Se tentarmos executar: "git push" dentro da branch "teste1" o terminal vai retornar a mensagem que tudo está atualizado. Mas a branch "teste2" está um "commit" a frente do repositório remoto como poderemos ver se mudarmos pra branch "teste2" com o comando: "git checkout teste2" e executarmos posteriormente: "git status".

44. Então agora sim vamos executar o "git push" para deixar tudo igual: repositório local e remoto. Executamos "git status" e fazemos "git checkout main" para confirmar tudo, também podemos ir no github e verificar cada uma das branches e arquivos.

Git Tag e Release:

45. Feito tudo, vamos criar uma "tag" que é como se fosse a "versão" do nosso repositório que pode ser um programa ou software e etc. Executando no terminal: "git tag -a 1.0.0 -m 'Versão Inicial'." E enviar para o repositório remoto: "git push --tags". Para verificar execute: "git show 1.0.0"

46. Depois é só fazer a "release" (lançamento) que vai estar na opção da "tag" no github.

.gitignore

47. Para projetos grandes geralmente se cria o arquivo de texto ".gitignore" para excluir arquivos de entrarem no projeto acidentalmente.

Fim deste super tutorial básico de Git e Github (por enquanto)?

Não, vamos aos "Comandos Avançados":

- "git log": para ver todo o "histórico de commits".

- "git rm -f arquivo.py": remove (deleta) o "arquivo.py".

- "git revert (+id do commit)": restaura o commit anterior (guarda o histórico).

- "git reset (+id do commit)": volta ao estado completo antes do commit (não guarda nenhum histórico).

- "git stash" (depois de executar o "git add ." em um arquivo modificado): retira um ou mais arquivos para uma área de "stash" que pode ser colocada novamente com o comando: "git stash apply (+ o índice da stash)", por exemplo executando o comando: "git stash list" e selecionando: "git stash apply "stash@{3}" ou apenas: "git stash apply 3" (sem tirar da stash), para aplicar e retirar da stash, utilizamos o comando: "git stash pop 3". E se quisermos limpar a "stash" utilizamos o comando: "git stash clear" (deletar tudo) ou "git stash drop 0" (para deletar apenas o índice selecionado). 

*Para criar e colocar uma mensagem na "stash" para ficar mais fácil de localizar na lista, utilizamos o comando: "git stash push -m 'mensagem' " e assim saberemos identificar melhor qual stash queremos após executar: "git stash list".

Agora sim talvez tenhamos acabado com os principais comandos de git/github no terminal.

Mas estas não são as únicas maneiras de utilizar o git/github (terminal e direto no website), existem as interfaces gráficas como: 

- > Github Desktop, Git Kraken, e outros que podem ser grátis (para 1 usuário em repositórios abertos) e pagos (para times e repositórios fechados).

-> VSCode puro e/ou + extensões como: GitLens, Git Pull-Requests, etc.

O que é isso (no Github)?

• Fork: copiar todo o repositório para o seu pŕoprio perfil para ter total liberdade para modificar o código e até realizar pull-requests
• issues: "problemas" que são relatados nos repositórios.
• project: planejamento do projeto em tabelas.
• actions: são automações para corrigir, atualizar, fazer deploy, etc.
• wiki: como se fosse uma enciclopédia do seu repositório, com várias páginas e etc.
• marketplace: loja de extensões para integração.
• gists: lugar para compartilhamento de código.
• githubpages: um site seu frontend grátis no github, tutorial completo em: https://pages.github.com/

->> Dica de OURO: Github Education - se você é estudante em instituição de ensino (fundamental, médio ou superior) a platafomra github oferece diversos benefícios, para saber todos os detalhes acesse: https://education.github.com/

Por fim... Por que não abordei conexão via SSH?
-> A resposta mais votada no Stackoverflow sobre o tema:

O GitHub mudou sua recomendação várias vezes (exemplo).

Parece que atualmente eles recomendam HTTPS porque é o mais fácil de configurar na mais ampla variedade de redes e plataformas, e por usuários que são novos em tudo isso.

Não há nenhuma falha inerente ao SSH (se houvesse, eles o desabilitariam) - nos links abaixo, você verá que eles também fornecem detalhes sobre as conexões SSH:

1. É menos provável que HTTPS seja bloqueado por um firewall.

https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls

Os URLs clones https:// estão disponíveis em todos os repositórios, independentemente da visibilidade. Os URLs clones https:// funcionam mesmo se você estiver atrás de um firewall ou proxy.

2. Uma conexão HTTPS permite que credential.helper armazene sua senha em cache.

https://docs.github.com/en/get-started/quickstart/set-up-git#connecting-over-https-recommended

Se você clonar com HTTPS, poderá armazenar em cache suas credenciais do GitHub no Git usando um auxiliar de credenciais. Para obter mais informações, consulte "Clonagem com URLs HTTPS" e "Armazenamento em cache de suas credenciais do GitHub no Git".

Extra:

Convenção de Commits - Tipo de Commit e Descrição:

• feat: Adiciona uma nova funcionalidade ao projeto.
• fix: Corrige um bug ou problema no projeto.
• docs: Altera a documentação do projeto. Ex.: README, comentários no código.
• style: Realiza mudanças na aparência, sem alterar a funcionalidade.
• refactor: Realiza mudanças no código que não alteram a funcionalidade.
• test: Adiciona ou modifica testes no projeto.

Referências:

• CONVENTIONAL COMMITS. Summary
• GITHUB. Configurar diretrizes para os contribuidores do repositório

CURIOSIDADE: se você estiver em um repositório github e aperta a tecla: "." (ponto final), você será redirecionado para um "visual studio code versão web" para editar o repositório. Se você apertar a tecla "," (virgula) será redirecionado para o Code Spaces que é quase a mesma coisa do outro, mas a diferença é que você pode usar os servidores para ver o código rodando.