Please enable JavaScript.

Coggle requires JavaScript to display documents.

Cloud Computing Course (Course 3 - Monolith to Microservices at Scale…

- - - - Utilizar aws-sdk
        
        Definir as credenciais
        
        Passar os parametros para
        o metodo
        getSignedUrl('getObject') ou
        getSignedUrl('putObject')
        
        Bucket
        
        Key
        
        Expires
      - Como utilizar o padrão signed URL do S3
        
        Seguindo o padrão Signed URL Pattern
        
        Client resquests resource to Server
        
        Server requests signedUrl to Filestore
        
        Filestore returns a signed Url
        
        Server returns a signed url
        
        Client loads the signed url
    - - Como fazer isso no node
      - process.env.VAR
    - - Para que o deploy de uma aplicação seja feito no ESB é preciso adicionar permissões a conta do desenvolvedor
      - Elasticbean full access permission
      - Administrator Acess
        
        Essa permissão deve ser removida após feito o deploy
        
        Somente através da conta root é possivel trocar permissões
    - - É preciso instalar o eb cli
      - Rodar o eb init escolhendo a região
      - Para poder fazer o deploy no arquivo criado
        dentro de .elasticbeanstalk, config.yml insira a linha:
        deploy:
        artifact: ./www/Archive.zip
      - rodar npm run build que vai fazer o build do Archive.zip
      - rodar o eb create dentro de diretório criado para fazer o deploy.
        escolhendo o nome do ambiente
      - Após isso tem que adicionar as variáveis de ambiente no EC2
        E dar o role que a instacia EC2 utiliza para o role do dev
      - Por último foi alterado o firewall do RDS para permitir qualquer conexao, deixando-o público (embora o professor recomende utilizar IAM para esses casos)
  - - - O basico do por que é necessário autenticação
      - Senhas é forma mais comum de autenticação
        
        Senhas NÃO podem ser salvas em texto plano
        
        Fácil de ser roubada
        
        Não pode ser salva mesmo em log
        
        Devem ser salvas com hash
        
        Hashes devem ser produzidas com bcrypt (one-way encryption)
        
        Hash devem ser 'salgadas'
        
        Para evitar serem descobertas em uma raibow table
        
        Raibow tables são tabelas onde um hacker passa um hash que encontrou e caso ela exista na tabela, ela retorna qual o textou gerou aquela hash
        
        Não se preocupe com processo computacional nessa hora
        
        Quanto maior a hash mais segura
        
        Devem ser transportadas por
        um protocolo encriptado (HTTPS).
        TLS SSL
        
        Muitas empresas grandes cometeram esse erro
    - - Se salva o hash com o salt
      - SaltRounds são as quantidades de iterações feitas pelo bcrypt para gerar o hash
      - Mostrou como utilizar bcrypt com node
        utlizando o pacote bcrypt e types/bcrypt
        
        Para comparar os passwords
        comparar o hash com a senhas com bcrypt.compare(plainPasswd, hash)
        
        Para gerar o hash
        
        gerar o salt com bcrypt.genSalt(saltRounds)
        
        gerar o hash com bcrypt.hash(plainPasswd, salt)
    - - Depois do cliente estar autorizado
        ele vai recebendo cookies de sessão o qual
        verificamos a cada requisição se ainda é valido
      - JWS tokens são tokens que podem ser armazenados
        no cliente, com o qual conseguimos saber se uma requisição
        é valida apenas verificando o hash
      - Serviços tambem acessam a aplicação através
        de um token
    - - usando o pacote jwt
      - Toda vez que o cliente logar ele receberá um token
      - o token é gerado pelo método jwt.sign(dados, secret)
      - Toda rota que utlizar a autenticacao precisa do middleware de autenticaçao com jwt
      - Quando autenticar uma requisição
        
        Pega a hash sem o Bearer
        
        verifica com jwt.verify(hash, secret, (err, decode) => {})
    - - Para fazer o deploy com as alterações
        utilizar agora o eb deploy
    - - Implemente políticcas de segurança
      - https://www.npmjs.com/policies/security
      - https://www.nylas.com/security/
      - https://aws.amazon.com/pt/security/
  - - - Algumas apresentações
    - - Alguma explicação de como funciona roteamento e DNS
      - AWS fornece Route 53 como serviço de DNS, com algumas vantagens, como poder referenciar outros serviços da amazon sem ter que saber qual o endereço.
    - - faça o deploy da pasta www para um S3
      - No projeto do curso apenas rode npm run build
      - CDN pode ser usado para melhorar a entrega
        do frontend para o cliente (assim como fizemos com arquivos)
      - Voce pode criar arquiovs de configuração para o deploy de cada ambiente, com as rotas e secrets necessárias
      - https://aws.amazon.com/premiumsupport/knowledge-center/cloudfront-serve-static-website/
    - - WARNING! Be careful when scaling your system on AWS. The free tier is limited in resources and resource type. Don't accidentally provision an expensive system and get hit with a bill later in the month ;)
      - Scaling UP
        
        Increase server
        
        Mudando EC2 Type
        
        Usando ElasticBeanStalk
        
        Procure por ElasticBeantalk
        
        Vá em Configuration
        
        No Painel Instances dá pra ver o type da instance
        
        Clique em modify
        
        Escolha o novo type
        
        Clique na aplicação
      - Scaling Out
        
        Usando ElasticBeanStalk
        
        Vá no ElasticBeanstalk
        
        Clique na aplicação
        
        Clique em configuration
        
        Veja em Capacity se auto-scaling está ativado
        
        Clique em modify
        
        Cheque que o type é Load Balance
        
        Escolha os Scaling Triggers
        
        https://docs.aws.amazon.com/elasticbeanstalk/latest/dg/environments-cfg-autoscaling-triggers.html
        
        Add server
        
        É preciso acresentar um Load Balancer
      - S3 escala normalmente
      - RDS Scaling
        
        https://aws.amazon.com/blogs/database/scaling-your-amazon-rds-instance-vertically-and-horizontally/
    - - Bug Reporting
        
        ElasticBeanStealk ferramentas de
        monitoramento
        
        Menu Health
        
        mostra as
        condições gerais de uma instância
        
        Menu Log
        
        Pode pegar os logs dos servidor
        
        Sentry é uma excelente ferramenta para mostrar o que está errado
      - Testing Concurrency
        
        WARNING! Amazon Web Services isn't really "cool" with load testing or other forms of aggressive testing like penetration testing on their platform. Be cautious before running these kinds of tests on AWS infrastructure to prevent your local IP from being blocked or your services being suspended.
        
        Siege é uma ferramenta pra isso
      - Monitoring the State of the System
        
        CloudFlare for improved DNS with monitoring and failover capabilities
        
        DataDog for stack performance and health status.
        
        AWS also has native tools to help monitor performance called CloudWatch.
  - - - Scalabillity
      - Secured
      - Permanent
    - - Indexes
      - NoSql
      - Banco de dados Relacional
    - - AWS RDS
      - Postbird
      - Configurar o RDS
        
        Busque pelo serviço RDS
        
        Escolha a engine
        
        Crie o Banco
        
        Cheque a opção de só aprensetar FreeTier options
        
        Defina as credenciais
        
        Selecione para que possa ser acessada publicamente
        
        Foi feito assim no curso, mas em produção não deve
        
        Activate postgres logs
        
        Create database
    - - Servem para grandes arquivos e documentos.
    - - Entre no serviço de S3 da aws
      - Clique em criar bucket
      - De um nome que seja unico
        
        Adicione dev no final para ter um set diferente de ambientes
      - Selecione a regiao
      - Adicione segurança
      - Crie o bucket
      - Adicione configuração CORS
    - - Credenciais devem ser revogaveis
      - Inforamações devem estar seguras
      - Credenciais devem dizer quem tem acesso e a que tem acesso
      - IAM
        
        Solução AWS
        
        Permissões para serviços
        
        Não precisam de usuario e senha
        
        Roles(Service) tem Policy Permission
        
        Criando Role
        
        Vá em Role
        
        Adicione Policies (pode ser as mesmas de Users)
        
        De um nome
        
        Permissões para usuários
        
        Podem ser agrupadas em Policy Group
        
        User tem Policy Permission
        
        Criando User
        
        Entre no painel IAM
        
        Vá em User
        
        Add User
        
        Escolha o nome (dev)
        
        Adicione permissão para acessar pelo console se quiser
        
        Crie um grupo para que multiplos usuários com as mesmas
        necessidades poderiam ter os acessos predefinidos
        
        Escolha um nome para o grupo (dev)
        
        Crie uma Policy para dar acesso somente ao bucket criado
        
        De um nome a Policy
        
        Adicione a Policy ao Grupo
        
        Adicione o grupo ao User
        
        Crie o usuario
        
        Baixe o .csv para instalar as chaves localmente
        
        Instalando credenciais localmente
        
        aws configure
        
        the credentias are the provided in the .csv file
        
        the region is the region of the resource (s3)
- - - - Summary
        Conceito de Microserviço
        Overview da Apicação Udagram
        Benefícios de Microserviços
        Preocupações Operacionais
    - - “Microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.”
      - James Lewis and Martin Fowlerm - https://www.martinfowler.com/microservices/
    - - Udagram
      - Frontend in angular e ionic
      - Rest API in Node (Feed/User)
      - RDS/Postgres
      - S3
    - - Independent scaling
      - Independent releases and deployments
      - Independent development
      - Decentralized governance
    - - Service replication
      - Service registration and discovery
      - Service monitoring and logging
      - Resiliency
      - DevOps
    - - Two-pizza team / Cross functional
      - Applications with high scalability needs
      - Projects with high release velocity
      - https://blog.christianposta.com/microservices/the-real-success-story-of-microservices-architectures/
  - - - Summary
        CI/CD Overview
        Travis as CI Example
    - - What is CI/CD
        
        Frequent releases
        
        Automated processes
        
        Repeatable
        
        Fast processing
      - What is CI
        
        Integration
        
        Testing
        
        Linting
        
        Building
      - What is CD
        
        Lifecycle Management
        
        Pipelines
        
        Deployable any time
    - - Small, Iterative Changes
      - Trunk-based Development or Git Flow
      - Fast Building and Testing Phases
      - Consistency Throughout the Deployment Pipeline
      - Decouple Deployment and Release
    - - On the root project crate a .travis.yml
      - Install the app in Github
  - - - Summary
        Docker Intro
        Building your first image
        Running the container
        Debugging a container
        Image Registry
        Docker compose
    - - Conceito de container no mundo real
        Onde as empresas encontrar um jeito de transportar
        diferentes tipos de produto da mesma forma.
    - - Create your dockerfile
      - Build the image
    - - use run to
        run a command in a new container
      - --publish publish a container’s port(s) to the host
      - --name assign a name to the container
    - - Check the logs with logs command
      - Debugging Inside The Container with exec command
    - - ps — List running containers.
      - run — Create a new container and start it.
      - create— Create a container from an image.
      - start— Start an existing container.
      - inspect— See lots of info about a container.
      - logs — Print logs.
      - stop — Gracefully stop running container.
      - kill —Stop main process in container abruptly.
      - rm— Delete a stopped container.
      - build— Build an image.
      - push — Push an image to a remote registry.
      - images — List images.
      - history (images) — See intermediate image info.
      - inspect (images) — See lots of info about an image, including the layers.
      - rm (images) — Delete an image.
    - - Upload images with docker push
  - - - Labels
      - pod.yaml
    - - Is the smaller unit in a kubernet
      - The pod idea came from the necessity
        to run many containers as a logical one
      - a specification for how to run the containers.
      - with shared storage/network
      - is a group of one or more containers
    - - Install Kubernetes On AWS Cluster Using KubeOne
        
        Installing Kubernetes
        
        Creating Infrastructure
        
        Setting Up Credentials
      - Setup the cluster
        
        KubeAWS
        
        Amazon EKS
        
        Kops
        
        KubeOne
        
        K8s Cluster on AWS
    - - What can Kubernetes really do?
        
        Provide native methods of service discovery
        
        Manage Stateless and Stateful Applications
        
        Easily integrate and support 3rd party apps
        
        Fire off jobs and scheduled cronjobs
        
        Blue/Green Deployments
        
        Autoscale Workloads
      - What Does Kubernetes do?
        
        Works as an engine for resolving state by converging actual and the desired state of the system.
        
        Abstracts away the underlying hardware of the nodes and provides a uniform interface for workloads to be both deployed and consume the shared pool of resources.
        
        Known as the linux kernel of distributed systems.
      - What is Kubernetes
        
        Designed from the ground-up as a loosely coupled collection of components centered around deploying, maintaining and scaling workloads
      - Made by Google (at first as a internal solution)
    - - Summary
        Intro into Kubernetes
        Creation of Kubernetes cluster
        Deployment of an microservice application as a pod
        Converting a pod into a deployment
    - - A Deployment controller provides declarative updates for Pods and ReplicaSets.
      - You describe a desired state in a Deployment object, and the Deployment controller changes the actual state to the desired state at a controlled rate.
      - You can define Deployments to create new ReplicaSets, or to remove existing Deployments and adopt all their resources with new Deployments.
  - - - Summary
        Configuration of the application
        Overview about Service registration and discovery
        Creation of a Service
        Connection service with deployment
        Scaling the application
    - - Configuration
        
        Kubernetes has an integrated pattern for decoupling configuration from application or container.
        
        This pattern makes use of two Kubernetes components
        
        ConfigMap
        
        Externalized data stored within kubernetes.
        
        Can be referenced through several different means
        
        environment variable
        
        a command line argument (via env var)
        
        injected as a file into a volume mount
        
        Can be created from a manifest, literals, directories, or files directly.
        
        Secret
        
        Functionally identical to a ConfigMap.
        
        Stored as base64 encoded content.
        
        Encrypted at rest within etcd (if configured!).
        
        Ideal for username/passwords, certificates or other sensitive information that should not be stored in a container.
        
        Can be created from a manifest, literals, directories, or from files directly.
    - - Using ConfigMap to env vars
      - Using secret to aws credentials
    - - When a service is scaled out how the client will know its IP?
      - Kubernetes handles the service discovery from beginning
    - - Cluster IP (default)
      - NodePort
      - LoadBalancer
      - External Name
    - - Unified method of accessing the exposed workloads of Pods.
      - Durable resource (unlike Pods)
      - Target Pods using equality based selectors.
      - Uses kube-proxy to provide simple load-balancing.
      - kube-proxy acts as a daemon that creates local entries in the host’s iptables for every service.
- - - - A buzzword (not a pattern/technology/architecture)
      - A spectrum of solutions
        
        servers are managed by someone else
        
        allow to scale up and down easily
        
        pay for what you use (expect for storage, no pay for idle)
        
        no administration
      - Benefits of Serveless
        
        Low entry barrier
        
        Cost efficient
        
        High-availability and scalability
      - Hurdles
        
        New architectural patterns
        
        New technology to learn
        
        New tools to learn
        
        Best practices are still not clear