DEV Community: VaiVoa

Design Pattern: Factory Method

Guilherme Pirani — Tue, 05 Apr 2022 20:52:56 +0000

Os designs de criação, nos quais se inclui o Factory, são utilizados para criar objetos sem expor ao cliente a lógica pela qual aquele objeto é criado. Assim, as subclasses ligadas a uma interface ou classe abstrata podem ser instanciadas sem que o cliente se importe com o tipo específico do objeto sendo criado.

De uma maneira mais prática, o diagrama abaixo é um exemplo de implementação de uma Factory:

Pode parecer sem sentido o simples ato de levar o construtor de um objeto para uma outra parte do programa, mas é justamente esse pequeno ato que gera a abstração que queremos, algo extremamente benéfico quando se trata de grandes projetos. Assim podemos sobrescrever o método de criação em uma subclasse, alterando o objeto criado, não é necessário reescrevermos toda a lógica de criação para cada subclasse que quisermos adicionar ao nosso programa, aplicamos princípios SOLID em nosso código, geramos um baixo acoplamento e facilitamos a manutenção.

Quando utilizar o Factory Method:

Quando o cliente não sabe de antemão o tipo de objeto que deverá ser criado.
Para permitir a extensão do código sem ter que realizar alterações em outras partes do projeto.
Para eliminar duplicação de código na criação de objetos.

Prós do Factory Method:

Evita acoplamento
Facilita Manutenção
Responsabilidade única (SOLID)
Aberto/Fechado (SOLID)

Contras do Factory Method:

Os produtos para serem retornados precisam ter uma classe ou interface base em comum.
Gera uma grande quantidade de classes no seu projeto. No entanto cabe aqui uma observação: é responsabilidade do desenvolvedor considerar os trade-offs daquilo que ele implementa. Nesse caso da quantidade de classes, podemos abrir mão de um pró do Factory de forma a diminuir a quantidade de classes, porém aumentando o acoplamento do código (usando switch case na Factory por exemplo, transformando o padrão em um Simple Factory)
Outros patterns podem oferecer mais flexibilidade, como Builder e Prototype, porém trazendo maior complexidade. Assim muitos projetos iniciam utilizando Factory e depois migram para outros design patterns.

Para um tutorial prático de como aplicar o Factory Method CLIQUE AQUI.

Guilherme PiraniFollow

Developer | Microsoft Learn Student Ambassador | AZ-900 | DP-900 | SC-900

Disclaimer

A VaiVoa incentiva seus Desenvolvedores em seu processo de crescimento e aceleração técnica. Os artigos publicados não traduzem a opinião da VaiVoa. A publicação obedece ao propósito de estimular o debate.

Setting up a virtual machine to run a scheduled job - Part 1 - Terraform, Serverless Framework and AWS

José Paiva — Mon, 04 Apr 2022 23:54:09 +0000

Hello, I'm José Silva, backend developer at Vaivoa, and today I'm going to teach you how to set up a ec2 machine at aws to run a cron job on a specific schedule with terraform and the serverless framework.

This article is the first of a series, which in the next steps, I'll explain how to use ansible to configure an ec2 instance dynamically to run a cron job and also configure git to always update the code before running the job.

Introduction

Terraform is a IaC tool, which helps you provide your cloud infrastructure with code. it's useful for versioning your infrastructure, documenting and automating your work.
EC2 is the AWS service for virtual machines. There's a free tier available, so don't worry about expenses(but still remember deleting all the resources created after the tutorial)
The serverless framework helps you deploy and configure lambda functions. We're going to write our lambda functions in python3.

The full code of the project is here: Github

Architecture

Next there's a picture representing the workflow:

Since we don't want the instance to be on 24/7, we'll rely on a lambda function to control the time the instance is up and running. The stop process will be taken care of by the instance itself. Since we don't know the time the job will take to execute(and for the most cases we can't predict), I'll encapsulate the job execution in a script that will take care of shutting down the instance once the job is finished.

For the scope of this part of the series, I'll focus only on starting the instance in a specific schedule.

Terraform

Let's start with our repository structure. First, terraform uses the working directory to get all information about your infrastructure. So let's create a directory just to put all the terraform config files. Every terraform command should be used inside the terraform directory.

tutorial/
    terraform/
        main.tf
        machine.tf
        vars.tf
        outputs.tf

inside main.tf, let's put this code:


terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "3.74.3"
    }
  }
}

provider "aws" {
  region = "your-favorite-region"
  profile = "your-aws-profile"
}

In the terraform part of the code, we tell which provider we're using, and which version of the provider we're using. Since I'm using version 3.74.3, if you want to know more about the terraform code i'm using, go to this version of the documentation.
In the provider section, we're telling which region we're going to deploy our infrastructure and what aws profile we're using to authenticate. Your profile is defined under the credentials file in your .aws/ folder.

Now, also in main.tf, we're using the data module to query the amazon linux 2 ami. It's useful because the same ami has different ids in different regions and so you don't have to look for it in the aws console:


data "aws_ami" "amazon_linux" {
  most_recent = true

  filter {
    name = "name"
    values = ["amzn2-ami-kernel-5.10-hvm*"]
  }

  filter {
    name = "architecture"
    values = ["x86_64"]
  }

  owners = ["137112412989"]
}

The amazon linux is an improved version of linux for aws, is supposed to be stable, safe and have a good performance. It's similar to Red Hat 7, so it uses yum as a package manager, for example.

Now let's write the vars.tf file. In this file we're going to set up all the terraform variables in the code. This allows us to:

Avoid hard coded values so it's easier to refactor our code.
Modularize our environment in case we want to deploy different configurations for development and production, for example.


variable "instance_size" {
  type = map(string)

  default = {
    "test" = "t2.micro"
    "prod" = "t2.medium"
  }
}

variable "network" {
  type = object({
    all_ipv4 = string
    all_ipv6 = string
    all_protocols = string
    all_ports = number
  })

  default = {
    all_ipv4 = "0.0.0.0/0"
    all_ipv6 = "::/0"
    all_protocols = "-1"
    all_ports = 0
  }
}

variable "disk" {
  type = map(number)

  default = {
    "test" = 16
    "prod" = 64
  }
}

variable "ssh_key" {
  type = string
  default = "my-ssh-key"
}

variable "inbound_rules" {
  type = object({
    port = number
    protocol = string
    description = string
  })

  default = {
    port = 22,
    protocol = "tcp",
    description = "Allow SSH"
  }
}

Here are the values we're using for the test environment. Feel free to change them as you want:

For instance type we're using the free tier, so you don't waste any money in this tutorial(as long as you still have the 750 hours per month to use).
For disk size, we're using 16 GB because is a reasonable size, but depending on the job you want to run, you might increase or decrease this size.

Next there's the machine.tf code. Here I'm setting up the ec2 machine configuration and the security group configuration. I'll explain each part separately.


resource "aws_instance" "tutorial_machine" {
  ami = data.aws_ami.amazon_linux.id
  instance_type = var.instance_size.test
  key_name = var.ssh_key
  security_groups = [aws_security_group.tutorial_sg.name]
  root_block_device {
    volume_size = var.disk.test
  }
  tags = {
    Name = "my_tutorial_machine"
  }
}

Here are some explanations:

The aws_instance keyword means it's an ec2 virtual machine.
The tutorial_machine is the local name terraform uses to reference the resource in code.
In the ami attribute, we're referencing the amazon linux 2 ami we queried in the data module in the main.tf file.
In the tags attribute, we're telling what the actual name of the virtual machine will be.
In the security groups, we're referencing a security group we're about to define next in the machine.tf file.

Here's the rest of the code:


resource "aws_security_group" "tutorial_sg" {
  name = "tutorial_sg"
  description = "Tutorial Security Group"

  ingress { #Inbound Rule
    from_port = var.inbound_rules.port
    protocol = var.inbound_rules.protocol
    to_port = var.inbound_rules.port
    cidr_blocks = [var.network.all_ipv4]
    ipv6_cidr_blocks = [var.network.all_ipv6]
    description = var.inbound_rules.description
  }

  egress { # Outbond Rule
    from_port = var.network.all_ports
    protocol = var.network.all_protocols
    to_port = var.network.all_ports
    cidr_blocks = [var.network.all_ipv4]
    ipv6_cidr_blocks = [var.network.all_ipv6]
  }

  tags = {
    Name = "Allow SSH Only"
  }

}

In the console, we can set up the security group or create a new one, if we create a new one, there's the default outbond rules allowing every traffic to the internet. With terraform, the security group has no default rule, so we have to specify everything we want.

In this security group we're setting two rules:

Allow all network traffic exiting the machine
Only allow traffic entering the machine through the ssh port number 22 from all hosts, both ipv4 and ipv6.

The 22 port is the default for ssh connections, which is something extremely important when configuring or using a virtual machine. In this part of the series we won't use it, but later we will.

Feel free to open more ports if your job needs it.

Finally, we're setting up some outputs to know some basic information about our deployed ec2 instance.


output "tutorial_public_dns" {
  value = aws_instance.tutorial_machine.public_dns
}

output "tutorial_instance_id" {
  value = aws_instance.tutorial_machine.id
}

Don't forget to change all the variables placeholders for your actual variables, like profile name, ssh key name, etc.

Now let's run some terraform commands:

Run terraform init inside the terraform folder. This command will install the aws provider runtime terraform relies on to understand what "aws_instance" or "aws_security_group" means.
Then run terraform plan to get a sample output of what might happen when you actually deploy your infrastructure and verify if there's any sintax errors in your code.
Now run terraform apply to deploy your machine. Terraform will show you what will be deployed again and will ask you to confirm your action by typing "yes" in the terminal.

After confirmation, you can go to your aws console, in the ec2 instances panel, and see your tutorial instance right there up and running!

Since we don't want our instance to be up and running 24/7, let's stop the instance and move on to the final part of the tutorial.

Lambda Functions & Serverless Framework

Now let's add a lambda directory to the tutorials folder and put the python script in it to start the ec2 instance, and the serverless.yml file to configure the lambda function.

tutorial/
    terraform/
        main.tf
        machine.tf
        vars.tf
        outputs.tf
    lambda/
        main.py
        serverless.yml

Under the lambda folder, in the main.py file, let's write our python code to start the instance based on the name tag:


import boto3


def handler(event, context):
    ec2 = boto3.client("ec2")
    response = ec2.describe_instances(
        Filters=[
            {
                'Name': "tag:Name",
                'Values': [
                    'my_tutorial_machine'
                ]
            }
        ]
    )

    instance_id = response['Reservations'][0]['Instances'][0]['InstanceId']

    response = ec2.start_instances(
        InstanceIds=[
            instance_id
        ]
    )
    print(response)


if __name__ == '__main__':
    handler({}, None)

Make sure the name tag is the same in both the main.py and the machine.tf.

I'm using boto3, which is the AWS SDK for Python3 and can be installed via pip. This SDK allows us to send API calls to aws in a easier way to start, stop, modify ec2 instances and much more.

The start instance operation relies on the instance id, which is something that changes for every deploy. Since we're using terraform and might deploy and redeploy our virtual machine a couple of times, the instance id will change accordingly, and every time it changes we'll have to adapt our python script. So we're first querying the instance information by name, which is something that doesn't change for every deploy.

Finally, let's write our serverless.yml, configuring the lambda runtime, stage, service name, aws region and IAM role statements.


service: tutorial-initializer

provider:
  name: aws
  stage: development
  runtime: python3.6
  region: your-favorite-region
  iamRoleStatements:
    - Effect: Allow
      Action:
        - ec2:DescribeInstances
        - ec2:StartInstances
      Resource: "*"

functions:
  initializer:
    handler: main.handler
    events:
      - schedule:
          enabled: true
          rate: your-cron-expression
    memorySize: 128
    timeout: 30

In the iamRoleStatements we're allowing our lambda function to perform the StartInstances and the DescribeInstances on any ec2 instance.

Here are some important things to know about the serverless.yml file:

In the functions part of the configuration, we're saying that the initializer lambda function will be the handler function in the main.py file.
The events part defines the cron schedule that will trigger the lambda function once the time is right.
The timeout defines the maximun time in seconds your lambda function is allowed to run. In this case 30 seconds is more than enough.
memorySize defines how much memory your function might have in MB. AWS uses this parameter to bill you(lambda function memory size multiplied by the total time of execution), so try to use a low value in here.

Finally, just run sls deploy inside your lambda folder and that's it! You just deployed a lambda function to start an EC2 instance based on a cron schedule.

Don't forget to replace the region and cron expression placeholders with your preferred region.
Also, keep in mind the schedule rate is based on the region time zone where your lambda is deployed. So calculate the difference between you local timezone and the aws region timezone to get the desired result.

Conclusion

Now you learned how to set up a virtual machine in AWS EC2 using free tier and setting up a lambda function to start the machine based on a cron schedule.

In the next modules I'll teach about configuring the machine with ansible, setting up the cron job to start on boot and updating the code with git.

The full code of the project is here: Github

To avoid further costs, after the completion of this tutorial, please run:

terraform destroy in your terraform folder, to destroy your ec2 instance and security group
sls remove in your lambda folder, to remove all of your deployed resources related to the serverless framework.

José PaivaFollow

Backend Developer at Vaivoa School of Excellence and Cloud Architect & DevoOps Engineer at Carteira Global.

Disclaimer

KAFKA + KSQLDB + .NET #1

Ricardo Medeiros — Tue, 30 Nov 2021 17:19:05 +0000

Hi, I'm Ricardo Medeiros, .NET back end developer @vaivoa, and today I'm going to walk you through using ksqlDB to query messages produced in kafka by a .NET/C# producer. For this example, I will be deploying my enviroment as containers, described in a docker compose file, to ensure easy reproducibility of my results.

The source code used in this example is avaliable here.

Services

First, let's talk about the docker compose environment services. the file is avaliable here.

.NET API Producer

Automaticaly generated .NET api with docker compose service

ksqldbdemo:
    container_name: ksqldbdemo
    image: ${DOCKER_REGISTRY-}ksqldbdemo
    build:
      context: .
      dockerfile: Dockerfile

This producer service needs the .NET generated dockerfile shown below:

FROM mcr.microsoft.com/dotnet/aspnet:5.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443

FROM mcr.microsoft.com/dotnet/sdk:5.0 AS build
WORKDIR /src
COPY ["ksqlDBDemo.csproj", "."]
RUN dotnet restore "ksqlDBDemo.csproj"
COPY . .
WORKDIR "/src/"
RUN dotnet build "ksqlDBDemo.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "ksqlDBDemo.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "ksqlDBDemo.dll"]

ZooKeeper

Despite not been necessary since Kafka 2.8, ZooKeeper coordinates kafka tasks, defining controllers, cluster membership, topic configuration and more. In this tutorial, it's used the confluent inc. ZooKeeper image, due to it's use in the reference material. It makes Kafka more reliable, but adds complexity into the system.

zookeeper:
    image: confluentinc/cp-zookeeper:7.0.0
    hostname: zookeeper
    container_name: zookeeper
    ports:
      - "2181:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000

Kafka

Kafka is an event streaming plataform capable of handling trillions of events a day. Kafka is based on the abstraction of an distributed commit log. Initialiy developed at LinkedIn in 2011 to work as a message queue, but it has evolved into a full-fledge event streanming platfmorm. Listed as broker in the services, is the core of this tutorial. It's configuration is tricky, but using it as follows worked well in this scenario.

 broker:
    image: confluentinc/cp-kafka:7.0.0
    hostname: broker
    container_name: broker
    depends_on:
      - zookeeper
    ports:
      - "29092:29092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: 'zookeeper:2181'
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://broker:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_GROUP_INITIAL_REBALANCE_DELAY_MS: 0
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1

ksqlDB

ksqlDB is a database built to allow distributed stream process applications. Made to work seamsly with kafka, it has a server that runs outside of kafka, with a REST API and a CLI application that can be run separatly and it's used in this tutorial.

ksqlDB Server

In this example, it's used the confluent inc image of the ksqlDB server, once more, due to it's widespread usage.

ksqldb-server:
    image: confluentinc/ksqldb-server:0.22.0
    hostname: ksqldb-server
    container_name: ksqldb-server
    depends_on:
      - broker
    ports:
      - "8088:8088"
    environment:
      KSQL_LISTENERS: http://0.0.0.0:8088
      KSQL_BOOTSTRAP_SERVERS: broker:29092
      KSQL_KSQL_LOGGING_PROCESSING_STREAM_AUTO_CREATE: "true"
      KSQL_KSQL_LOGGING_PROCESSING_TOPIC_AUTO_CREATE: "true"

ksqlDB CLI

The same goes for the ksqlDB CLI service, that also use the confluent inc image.

ksqldb-cli:
    image: confluentinc/ksqldb-cli:0.22.0
    container_name: ksqldb-cli
    depends_on:
      - broker
      - ksqldb-server
    entrypoint: /bin/sh
    tty: true

Kafdrop

Kafdrop is a Web UI for viewing kafka topics and browsing consumer groups. It makes kafka more accessible.

kafdrop:
    container_name: kafdrop
    image: obsidiandynamics/kafdrop:latest
    depends_on:
      - broker
    ports:
      - 19000:9000
    environment:
      KAFKA_BROKERCONNECT: broker:29092

Tutorial

Now it's the time that you have been waiting, let's make it work!

Enviroment

For this tutorial, you'll need a docker desktop installation, either it's on a Linux distribution or on Windows with WSL and git.

Cloning the project

A Visual Studio project is avaliable here, it has docker support and already deploys all the services needed for this demo in the IDE. However, you will be fine if you don't want or can't use Visual Studio. Just clone it, running the following comand on the terminal and directory of your preference:

 $ git clone https://github.com/jjackbauer/ksqlDBDemo.git

Use the following command to move to the project folder:

 $ cd /ksqlDBDemo

And, in the project folder, that contains the docker-compose.yml run the following command to deploy the services:

$ docker compose up -d

after this command, make sure that all services are running. Sometimes services fall, but it is okay. In order to see if everything is running ok, it's possible to see the services running in docker desktop, as shown bellow:

Or you can execute the following command:

$ docker ps

Which should output something like this:

CONTAINER ID   IMAGE                               COMMAND                  CREATED       STATUS       PORTS
  NAMES
b42ce9954fd9   ksqldbdemo_ksqldbdemo               "dotnet ksqlDBDemo.d…"   2 hours ago   Up 2 hours   0.0.0.0:9009->80/tcp, 0.0.0.0:52351->443/tcp   ksqldbdemo
0a0186712553   confluentinc/ksqldb-cli:0.22.0      "/bin/sh"                2 hours ago   Up 2 hours
  ksqldb-cli
76519de6946e   obsidiandynamics/kafdrop:latest     "/kafdrop.sh"            2 hours ago   Up 2 hours   0.0.0.0:19000->9000/tcp
  kafdrop
11c3a306ee01   confluentinc/ksqldb-server:0.22.0   "/usr/bin/docker/run"    2 hours ago   Up 2 hours   0.0.0.0:8088->8088/tcp
  ksqldb-server
07cef9d69267   confluentinc/cp-kafka:7.0.0         "/etc/confluent/dock…"   2 hours ago   Up 2 hours   9092/tcp, 0.0.0.0:29092->29092/tcp
  broker
3fa1b9a60954   confluentinc/cp-zookeeper:7.0.0     "/etc/confluent/dock…"   2 hours ago   Up 2 hours   2888/tcp, 0.0.0.0:2181->2181/tcp, 3888/tcp     zookeeper

WEB API

Now, with all services up and running, we can access the WEB API Swagger to populate our Kafka topics. The code is very simple and it's avaliable in the repository.

The WEB API swagger is deployed at http://localhost:9009/swagger/index.html. As shown in the image bellow, it has two endpoints and they create events that could be created by indepent microservices. One for creating an event that creates a userName in the system and another that takes an Id and generates a three digit code.

Then you can create an User with the user name of your choise, as shown:

And it will have an assigned unique Id, as demonstrated:

Now, you can get a three digit code for your user Id as displayed:

And a random code is generated for the selectd, as we can observe in the image that follows:

Kafdrop

We can use the kafdrop UI the check if everything is okay. Kafdrop is deployed at http://localhost:19000/.
There, you will find all the brokers and topics avaliable. It should look like this:

KSQL CLI

After all that, you'll be able to create your streams of data and query it using ksqlDB. On your preferential terminal, use the command:

docker exec -it ksqldb-cli ksql http://ksqldb-server:8088

Creating streams

And then you are in the ksql CLI and are free to create your streams and queries. First, let's create a stream for each one of our topics:

CREATE STREAM stream_user (Name VARCHAR, Id VARCHAR)
  WITH (kafka_topic='demo-user', value_format='json', partitions=1);

CREATE STREAM stream_code (Id VARCHAR, code INT)
  WITH (kafka_topic='demo-code', value_format='json', partitions=1);

Create a materialized view

You can join the client data with the most recent randomized code. to achieve this, you must create a materialized view table, that joins both streams as seen in the ksqldb script that follows:

CREATE TABLE currentCodeView AS
>   SELECT user.Name,
>   LATEST_BY_OFFSET(code.code) AS CurrentCode
>   FROM stream_code code INNER JOIN stream_user user
>   WITHIN 7 DAYS ON code.Id = user.Id
>   GROUP BY user.Name
>EMIT CHANGES;

Making a push query

After that, we can query this materialized view:

SELECT * FROM currentCodeView 
  EMIT CHANGES;

This push query keep on running until you hit cntrl+c to cancel it.

Conclusions

In this tutorial it's demonstrated that in a kafka + ksqlDB enviroment, you can make SQL queries and also join on data that comes from different events, which is one of most complexities envolved with microsservices systems. And it is what ksqlDB solves by enabling SQL operations over Kafka topics.
It's my goal to explore the possibilites allowed by this ecosystem and I hope to bring more knowledge on this topic in another articles here. Any sugestions, comments or corrections, fell free to reach me out at LinkedIn.

Ricardo MedeirosFollow

Senior Cloud Software Engineer @Caylent

References

ksqlDB Quickstart
ksqlDB Overview
Kafka .NET Client
ksqlDB Documentation - Data Types Overview
KSQL and ksqlDB
Welcome to Apache ZooKeeper
What is ZooKeeper & How Does it Support Kafka?
What is Apache Kafka®?
ksqlDB - The database purpose-built for stream processing applications
An overview of ksqlDB
CREATE TABLE AS SELECT
How to join a stream and a stream
Time and Windows in ksqlDB Queries
Time operations

Disclaimer

Mercado Financeiro: Onboarding para Devs.

Lucas Paes — Mon, 22 Nov 2021 21:54:52 +0000

Eae Devs, tudo de boas?

Hoje vou abordar um tema um pouco fora do contexto de “programar”, mas que se tornou muito relevante para mim, pois foi necessário se aprofundar um pouco nele para conseguir se adequar a alguns conceitos dentro da squad, e queria compartilhar os meus estudos com vocês. Farei uma introdução ao mercado brasileiro de investimentos, para servir de base para outras pessoas que assim como eu estão entrando nessa área sem saber muito.

> Vamos começar pela B3

B3 (Brasil, Bolsa e Balcão) é a bolsa de valores oficial do Brasil, sediada em São Paulo e fundada em 2017 pela fusão do Bovespa + BM&F + Cetrip. É considerada uma das 10 maiores bolsas de valores do mundo e a maior da américa latina. A B3 funciona como um mercado de negociações, sendo o “lugar” onde ocorre a compra e venda de ativos financeiros como: ações, fundos, derivativos, commodities, contratos e entre outros. As principais empresas dos setores econômicos estão dentro da bolsa do Brasil, comtemplando setores como: financeiro, industrial, petróleo e gás, saúde, biocombustível, tecnologia.

Para uma empresa entrar na B3, ou seja, negociar as suas ações, é necessário realizar o IPO (Initial Public Offering) ou oferta pública inicial, que torna a empresa uma instituição de capital aberto, representando a primeira vez que novos sócios farão parte da organização.

As transações na B3 ocorrem por meio das corretoras de valores (como a XP, Rico, Nu invest e Modalmais), também chamadas de Broker-dealer, que são instituições financeiras com foco no mercado de investimento, funcionando como um intermediário entre pessoas físicas e investimentos, elas funcionam com autorizações de órgãos reguladores.

Um termo importante referente a B3 é o Circuit Breaker, em situações muito especiais as negociações podem ser interrompidas, isso serve como um mecanismo de proteção para os investidores, porque defende eles contra as variações bruscas do mercado e gera um pouco de tempo para os investidores pensarem em soluções.

O Ibovespa ou IBOV é o principal índice da B3 e concentra os resultados das ações das grandes empresas dentro da bolsa, um índice é uma carteira teórica de ações funcionando como um termômetro, ou seja, um indicador de desempenho médio de um ativo ou um conjunto de ativos.

Atualmente a bolsa brasileira conta com aproximadamente 3,8 milhões de pessoas físicas e com cerca de um volume diário R$ 34,031 bilhões.

> E quais os tipos de investimentos?

Podemos dividir os investimentos em 2 seguimentos: renda variável e renda fixa. Cada um tem suas peculiaridades e investidor alvo, no mercado financeiro existe também perfis de investidores, que são nomenclaturas para identificar os melhores investimentos para determinado cliente, os principais perfis são: conservador, moderado e arrojado ou agressivo.

Renda Variável: São investimentos que apresentam rentabilidade inserta, ou seja, antes da aplicação não é possível saber se tal investimento trará lucro ou prejuízo ao investidor, o valor vai variar de acordo com as condições atuais do mercado, porém esse tipo de investimento pode trazer mais rentabilidade mas também inclui mais riscos. Alguns dos ativos nesse seguimento são: Ações, Fundos, Criptomoedas, FII, ETFS, COE, Cambio, Ouro e afins.

Renda Fixa: Funcionam como uma espécie de empréstimo monetário ao governo, banco ou empresa, esperando receber esse dinheiro de volta acrescido de uma remuneração, diferente da renda variável, nesse tipo de investimento é possível prever a rentabilidade, pois geralmente é fixada em alguma porcentagem ao mês e/ou em índices financeiros como a taxa SELIC, o CDI, o IPCA e afins. Nesse seguimento se encontra os ativos: LCI, LCA, CRI, CRA, Poupança, Debêntures, CDBs e outros. Existe 3 tipos de investimentos dentro desse grupo, os Pré-fixados que informam desde o começo para o investidor a sua rentabilidade, Pôs-fixados que só é possível saber sua rentabilidade no final do empréstimo e os Híbridos que tem uma taxa fixa e variável que determina a rentabilidade final.

> Vamos nos aprofundar um pouco mais nos principais ativos financeiros

Ações: Representa a menor parcela do capital de uma empresa, quem compra ações de uma companhia adquire os direitos e deveres de um sócio, essas ações são adquiridas em lotes, que por padrão tem 100 unidades, mas também é possível adquirir ações pelo mercado fracionário, para entrar nesse mercado basta acrescentar a letra “F” ao final da ação (VALE3F, PETR3F), permitindo assim comprar poucas unidades e pagar menos para realizar transações na bolsa. As ações da B3 são divididas entre, Small Caps que são ações de empresas de menor valor, Mid Caps referentes a empresas medianas e Large Caps ou conhecidas também como Blue Chips que são as ações das grandes empresas, ou seja, as mais negociadas da bolsa. Possuem também dois tipos: as Ordinárias (ON) que dão direito a voto em assembleias dentro da empresa e possuem o digito 3 no final (PETR3, VALE3, BBAS3), e as preferenciais (PN) que garantem prioridade na divisão dos dividendos.

Fundos: São gestores/investidores que captam recursos de diversas pessoas para que sejam aplicados em conjunto no mercado financeiro, de modo que o lucro é dividido entre cada participante na proporção do valor aplicado em relação ao montante. A soma de todo o dinheiro arrecadado forma o patrimônio do fundo, e as decisões que os gestores desse fundo iram tomar com esse capital devem obedecer a regas e objetivos previamente determinados e públicos. Os fundos são divididos em cotas e adquiridos por unidade, também é cobrado uma taxa de administração e uma taxa de performance caso o fundo obtenha uma rentabilidade acima do esperado. Os principais tipos de fundos são: fundo de renda (tijolo) investem diretamente em imóveis físicos, fundos de recebíveis (papel) conhecidos como FII de CRI, não ocorre a compra efetiva de imóveis e sim aplicações no setor como LCI e CRIS, fundo de fundos (FOFs) que compram cotas de outros fundos para diversificação, fundo multimercado, fundo de ações, fundo de índices e entre outros.

Derivativos: São instrumentos financeiros com o preço baseado em outro ativo, que pode ser do tipo físico como a soja ou o café, ou podem ser financeiros como ações e índices. Existem alguns tipos de derivativos sendo: mercado a termo, mercado futuro, opções e Swaps. Nesse tipo de ativo as transações geram contratos de direitos ou obrigações de compra e venda, com preços e datas definidas, mas que em alguns modelos podem variar conforme o mercado.

CDBs: Os Certificados de Depósito Bancário estão entre os mais conhecidos dos rendimentos fixos, nesse modelo você empresta dinheiro para o banco financiar suas atividades de crédito, e em troca é oferecido uma remuneração que no caso seria os juros por um determinado período, como por exemplo um CDB que paga 100% do CDI ao ano.

LCI e LCA: A Letra de Crédito Imobiliário e a de Agronegócio são outros dois ativos de renda fixa que ganharam bastante lugar na bolsa e nas carteiras de investidores, ambos são isentos de imposto de renda e assim como os CDBs, você empresta dinheiro para uma instituição e recebe os juros sobre esse valor.

> Outros protagonistas do mercado financeiro

Sistema Sinacor: É um sistema integrado de administração de corretoras fornecido pela B3, estruturados em módulos, bem parecido com um ERP, algum deles são: alocação, ordens, faturamento, custódia, tesouraria, contabilidade e cadastro de clientes. Todas as movimentações na bolsa dos clientes das corretoras são controladas pelo Sinacor, tudo fica computado no sistema. Oferecendo uma série de serviços administrativos para as corretoras, cadastrando, armazenando e disponibilizando os dados das transações de seus usuários, você já deve ter ouvido falar sobre as notas de corretagem e é por meio desse sistema que elas são geradas, fornecendo um “extrato” geral de todas as transações.

Anbima: Associação brasileira das entidades dos mercados financeiros e de capitais, fundada em 2009 por uma fusão da Ambid e Andima, conta com mais de 340 associados (bancos, corretoras e gestoras). É uma organização civil que representa os interesses do setor privado do mercado financeiro, oferecendo ferramentas e regulamentações para os profissionais do setor, possui 4 pilares centrais: educar, informar, representar e autorregular. O foco da Anbima é ser um centro de informação para proporcionar transparência ao setor, educando e informando os profissionais da área e assim aumentando a qualidade como um todo. Ela possui as principais certificações do setor para esses profissionais (CPA-10, CPD-20, CEA e outras).

> Agora um pouco de "programação" #SQN

As instituições financeiras recebem e enviam diariamente inúmeros dados sobre as transações na bolsa e integrações com outros sistemas, visando deixar essa comunicação padrão e facilitar a integração (aumentando a velocidade de implantação e diminuindo o custo) foi desenvolvido o protocolo FIX. O Financial Information eXchange (FIX) foi lançado em 1992 e vem sendo utilizado como padrão mundial para a troca de informações relacionadas as transações de valores imobiliários, dados de mercado (ambiente de trading), operações, ativos na bolsa, usado em robôs trading e em muitas outras partes do sistema financeiro. O FIX foi desenvolvido pela comunidade em conjunto com diversas instituições financeiras espalhas pelo mundo. Para a sua segurança o protocolo utiliza criptografia de transmissão Stunnel + SSL e para assegurar os dados usa PGP-DES-MD5. Está em constante evolução por ser gratuito e aberto com versões já em 5.0.

A mensagem transmitida pelo protocolo FIX segue o padrão ASCII (apenas texto), e é construída utilizando o conceito de chave e valor, no caso do protocolo essa chave tem o nome de Tag e são numéricas.

TAG=VALUE
8=FIX.4.4

A estrutura padrão das mensagens FIX é composta de 3 tópicos, o HEADER que contém dados gerais e informativos sobre a mensagem, o BODY que é constituído por varias sequências de dependendo do tipo de mensagem/ação que a mensagem quer passar e tem a função de armazenar os principais dados, como contas bancarias, quantias, identificadores do cliente e dos bancos. E por fim o TRAILER que é usado para separar mensagens e conter as assinaturas e o CheckSum da mensagem (sempre é a última tag da mensagem e com 3 caracteres). Segue um exemplo de uma mensagem no padrão FIX:

8=FIX.4.4|9=122|35=D|34=215|49=CLIENT12|52=20100225-19:41:57.316|56=B|1=Marcel|11=13346|21=1|40=2|44=5|54=1|59=0|60=20100225-19:39:52.020|10=072|

Utilize a ferramenta FIX Parse para ler a mensagem.

Para mais informações sobre o FIX deixo aqui um vídeo Anatomy of the FIX Protocol.

Você vera algo parecido com essa estrutura, é possível verificar todas as tags e seus usos neste dicionário FIX disponibilizado pela Onixs FIX Dictionary

> Por enquanto é isso, obrigado! ✌️

Qualquer dúvida pode me chamar para um bate-papo, e agradeço a sua atenção até aqui, espero te ver em outras publicações.

.ltag__user__id__729246 .follow-action-button { background-color: #000000 !important; color: #ffffff !important; border-color: #000000 !important; }

Lucas PaesFollow

Brasileiro, 22 anos. Amo tecnologia e estou sempre explorando novos conhecimentos.

Disclaimer

Desenvolvimento Swift no Windows com WSL

Victor Mello — Mon, 22 Nov 2021 19:22:53 +0000

Com alguns plugins e o Language Server Protocol do Swift e Object-C é possível desenvolver em swift no Windows utilizando o VS Code.

Requerimentos

WSL2 - Para instalar basta ir em http://aka.ms/wsl2 e seguir as instruções.
VS Code - Ide que será utilizada.
Node - Para compilar a extensão do VS Code.

LSP para Swift

O LSP (Language Server Protocol) é o que permite o VS Code e outras IDEs proverem recursos como auto complete, lint e encontrar referencias para divérsas linguagens de programação.
Para utilizar um precisamos de um servidor LSP da linguagem, e o plugin na IDE.

O toolchain do swift prove um servidor LSP, e pode ser baixado em https://swift.org/download/ .
Baixe a mesma versão do seu linux. No meu caso Ubuntu 20.04

Para instalar todo o toolchain, basta copiar os arquivos para sua pasta /usr com os comandos:

tar -xzf swift-5.5-RELEASE-ubuntu20.04.tar.gz
cd swift-5.5-RELEASE-ubuntu20.04/usr
sudo cp -r ./ /usr/

Para testar, execute o comando sourcekit-lsp -h. Deve ser retornado o help do mesmo.

Plugin do VS Code

Para o VS Code se comunicar com o servidor, é necessário um plugin.

Como o plugin compilado não é distribuído pela Apple, é necessário compilar o mesmo. Porem o processo é bem simples.

Basta rodar os comandos abaixo. Que irão baixar, compilar e instalar o plugin no seu VS Code.

git clone https://github.com/apple/sourcekit-lsp.git
cd sourcekit-lsp/Editors/vscode/
npm install
npm run dev-package
code --install-extension sourcekit-lsp-development.vsix

WSL e VS Code

Para que o VS Code se comunique com o linux em WSL, é necessário instalar a extensão Remote WSL

Com a Remote WSL instalada, clique no botão Open a Remote Window, no canto inferior esquerdo do VS Code.
Selecione New WSL Window ou Reopen Folder in WSL.

Com o WSL ativo, é necessário habilitar as extensões para também funcionarem em WSL.
Vá até Extensões, selecione SourceKit-LSP e clique na opção Install in WSL.

Agora, assim que um arquivo .swift for aberto, o servidor LSP do swift será iniciado e estará comunicando com o VS Code.

Rodando um .swift

Para rodar um código swift, recomendo a extensão formulahendry.code-runner.
Com Code Runner instalado no WSL, basta clicar no ícone de play ou apertar CTRL + ALT + N
com o arquivo aberto.

É possível rodar swift em outras IDEs

SIM! A ideia do LSP é ter um protocolo padrão para diversas IDEs darem suporte a mesma linguagem.

É possível encontrar mais detalhes de como rodar swift em outros editores no GitHub do sourcekit-lsp

Victor MelloFollow

Dev curioso por novas stacks, sempre querendo aprender algo novo e ajudar os outros no processo.

Disclaimer

Eliminando o Toil

Marcos Rocha — Mon, 22 Nov 2021 18:55:41 +0000

Eliminando o Toil

Se um operador humano precisar tocar seu sistema durante as operações normais, você tem um bug. A definição de normal muda à medida que seus sistemas crescem.
Carla Geisser, Google SRE

Na SRE, queremos dedicar mais tempo ao trabalho de projeto de engenharia de longo prazo, ao invés do trabalho operacional. Como o termo trabalho operacional pode ser mal interpretado, usamos uma palavra específica: toil.

Definição de toil

toil não é apenas “trabalho que não gosto de fazer”. Também não é equivalente a tarefas administrativas ou trabalho sujo. As preferências quanto aos tipos de trabalho que são satisfatórios e agradáveis variam de pessoa para pessoa e algumas pessoas até gostam de trabalhos manuais e repetitivos. Há também tarefas administrativas que precisam ser feitas, mas não devem ser categorizadas como toil: isso é sobrecarga. A sobrecarga costuma ser um trabalho não diretamente vinculado à execução de um serviço de produção e inclui tarefas como reuniões de equipe, definição e classificação de metas, formulários e papelada de RH. O trabalho sujo às vezes pode ter um valor de longo prazo e, nesse caso, também não é toil . Limpar toda a configuração de alerta do seu serviço e remover a confusão pode ser sujo, mas não é toil.

Então, o que é toil? O toil é o tipo de trabalho vinculado à execução de um serviço de produção que tende a ser manual, repetitivo, automatizado, tático, desprovido de valor duradouro e que escala linearmente à medida que o serviço cresce. Nem toda tarefa considerada toil tem todos esses atributos, mas quanto mais de perto o trabalho corresponder a uma ou mais das seguintes descrições, mais provável será que seja árduo:

Manual

Isso inclui trabalhos como a execução manual de um script que automatiza algumas tarefas. Executar um script pode ser mais rápido do que executar manualmente cada etapa do script, mas o tempo prático que um ser humano gasta executando esse script (não o tempo decorrido) ainda é tempo de trabalho.

Repetitivo

Se você está realizando uma tarefa pela primeira vez, ou mesmo pela segunda vez, este trabalho não é árduo. O toil é o trabalho que você faz continuamente. Se você está resolvendo um novo problema ou inventando uma nova solução, este trabalho não é árduo.

Automatizável

Se uma máquina pode realizar a tarefa tão bem quanto um ser humano, ou a necessidade da tarefa pode ser projetada para longe, essa tarefa é toil. Se o julgamento humano é essencial para a tarefa, há uma boa chance de não ser toil.

Tático

O trabalho é orientado por interrupções e reativo, em vez de orientado por estratégia e proativo. Lidar com alertas constantes é árduo. Talvez nunca possamos eliminar totalmente esse tipo de trabalho, mas temos que trabalhar continuamente para minimizá-los.

Sem valor duradouro

Se o seu serviço permanecer no mesmo estado depois de terminar uma tarefa, provavelmente a tarefa foi árdua. Se a tarefa produziu uma melhoria permanente em seu serviço, provavelmente não foi árdua, mesmo se alguma quantidade de trabalho pesado – como mergulhar em códigos e configurações legados e corrigi-los – estivesse envolvida.

O(n) com o crescimento do serviço

Se o trabalho envolvido em uma tarefa aumenta linearmente com o tamanho do serviço, volume de tráfego ou contagem de usuários, essa tarefa provavelmente é árdua. Um serviço gerenciado e projetado idealmente pode crescer em pelo menos uma ordem de magnitude com zero trabalho adicional, exceto alguns esforços únicos para adicionar recursos.

Por que menos toil é melhor

Nossa organização SRE tem uma meta anunciada de manter o trabalho operacional (ou seja, toil) abaixo de 50% do tempo de cada SRE. Pelo menos 50% do tempo de cada SRE deve ser gasto no trabalho do projeto de engenharia que irá reduzir o trabalho futuro ou adicionar recursos ao serviço. O desenvolvimento de recursos normalmente se concentra em melhorar a confiabilidade, o desempenho ou a utilização, o que geralmente reduz o toil como um efeito de segunda ordem.

Compartilhamos essa meta de 50% porque o toil tende a se expandir se não for verificado e pode preencher rapidamente 100% do tempo de todos. O trabalho de redução de toil e ampliação de serviços é a “Engenharia” em Site Reliability Engineering. O trabalho de engenharia é o que permite que a organização SRE se expanda sublinearmente com o tamanho do serviço e gerencie os serviços de forma mais eficiente do que uma equipe de Dev ou de operações pura.

Além disso, quando contratamos novos SREs, prometemos a eles que a SRE não é uma organização de operações típica, citando a regra de 50% mencionada acima. Precisamos cumprir essa promessa, não permitindo que a organização SRE ou qualquer subequipe dentro dela se transforme em uma equipe operacional.

Calculando o toil

Se buscamos limitar o tempo que um SRE gasta com toil para 50%, como esse tempo é gasto?

Há um limite mínimo para a quantidade de trabalho que qualquer SRE precisa lidar se estiver de plantão. Um SRE típico tem uma semana de plantão primário e uma semana de plantão secundário em cada ciclo. Segue-se que, em uma rotação de 6 pessoas, pelo menos 2 de cada 6 semanas são dedicadas a turnos de plantão e tratamento de interrupção, o que significa que o limite inferior do trabalho potencial é 2/6 = 33% do tempo de um SRE. Em uma rotação de 8 pessoas, o limite inferior é 2/8 = 25%.

Consistente com esses dados, os SREs relatam que sua principal fonte de trabalho são as interrupções (ou seja, mensagens não urgentes relacionadas ao serviço e e-mails). A próxima fonte principal é a resposta de plantão (urgente), seguida por comunicados e envios. Mesmo que nossos processos de release e push sejam geralmente tratados com uma boa quantidade de automação, ainda há muito espaço para melhorias nesta área.

Pesquisas trimestrais dos SREs do Google mostram que o tempo médio gasto trabalhando é de cerca de 33%, então nos saímos muito melhor do que nossa meta geral de 50%. No entanto, a média não captura outliers: alguns SREs alegam 0% de toil (projetos de desenvolvimento puro sem trabalho de plantão) e outros alegam 80% de toil. Quando SREs individuais relatam trabalho excessivo, geralmente indica a necessidade de que os gerentes distribuam a carga de trabalho de maneira mais uniforme pela equipe e incentive-os a encontrar projetos de engenharia satisfatórios.

O que se define como Engenharia?

O trabalho de engenharia é novo e requer intrinsecamente julgamento humano. Produz uma melhoria permanente no seu serviço e é orientada por uma estratégia. Frequentemente, é criativo e inovador, adotando uma abordagem orientada ao design para resolver um problema – quanto mais generalizado, melhor. O trabalho de engenharia ajuda sua equipe ou a organização SRE a lidar com um serviço maior, ou mais serviços, com o mesmo nível de pessoal.

As atividades SRE típicas se enquadram nas seguintes categorias aproximadas:

Engenharia de software

Envolve escrever ou modificar o código, além de qualquer projeto associado e trabalho de documentação. Os exemplos incluem escrever scripts de automação, criar ferramentas ou estruturas, adicionar recursos de serviço para escalabilidade e confiabilidade ou modificar o código de infraestrutura para torná-lo mais robusto.

Engenharia de sistemas

Envolve configurar sistemas de produção, modificar configurações ou documentar sistemas de uma forma que produza melhorias duradouras a partir de um esforço único. Os exemplos incluem configuração e atualizações de monitoramento, configuração de balanceamento de carga, configuração do servidor, ajuste de parâmetros do sistema operacional e configuração do load balancer. A engenharia de sistemas também inclui consultoria em arquitetura, design e produção para equipes de desenvolvedores.

toil

Trabalho diretamente vinculado à execução de um serviço que é repetitivo, manual, etc.

Sobrecarga

Trabalho administrativo não vinculado diretamente à execução de um serviço. Os exemplos incluem contratação, papelada de RH, reuniões de equipe/empresa, higienização de filas de bugs, formulários, revisões de pares, auto avaliações e cursos de treinamento.

Cada SRE precisa despender pelo menos 50% de seu tempo em trabalho de engenharia, em média em alguns trimestres ou um ano. O toil tende a ser pontiagudo, portanto, 50% do tempo gasto em engenharia pode não ser realista para algumas equipes de SRE, e eles podem cair abaixo dessa meta em alguns trimestres. Mas se a fração de tempo gasto em projetos fica em média significativamente abaixo de 50% no longo prazo, a equipe afetada precisa dar um passo atrás e descobrir o que está errado.

O toil é sempre ruim?

O toil não torna todos infelizes o tempo todo, especialmente em pequenas quantidades. Tarefas previsíveis e repetitivas podem ser relaxantes. Elas produzem um sentimento de realização e vitórias rápidas. Elas podem ser atividades de baixo risco e baixo estresse. Algumas pessoas gravitam em torno de tarefas que envolvem toil e podem até gostar desse tipo de trabalho.

O toil nem sempre é invariavelmente ruim, e todos precisam estar cientes de que alguma quantidade de toil é inevitável na função de SRE e, na verdade, em quase qualquer função de engenharia. É bom em pequenas doses, e se você está feliz com essas pequenas doses, o toil não é um problema. O trabalho torna-se tóxico quando experimentado em grandes quantidades. Se você está sobrecarregado com muito trabalho, deve se preocupar e reclamar em voz alta. Entre as muitas razões pelas quais trabalhar demais é ruim, considere o seguinte:

Estagnação de carreira

O progresso de sua carreira diminuirá ou será interrompido se você investir pouco tempo em projetos. O Google recompensa o trabalho sujo quando é inevitável e tem um grande impacto positivo, mas você não pode fazer carreira fora da sujeira.

Baixa moral

As pessoas têm limites diferentes para a quantidade de toil que podem tolerar, mas todos têm um limite. Muito toil leva ao esgotamento, ao tédio e ao descontentamento.

Além disso, gastar muito tempo trabalhando em detrimento do tempo gasto com engenharia prejudica uma organização SRE das seguintes maneiras:

Cria confusão

Trabalhamos muito para garantir que todos os que trabalham na ou com a organização SRE entendam que somos uma organização de engenharia. Indivíduos ou equipes dentro de SRE que se envolvem em muito toil prejudicam a clareza dessa comunicação e confundem as pessoas sobre o nosso papel.

Retarda o progresso

O trabalho excessivo torna a equipe menos produtiva. A velocidade do recurso de um produto diminuirá se a equipe SRE estiver muito ocupada com trabalho manual e combate a incêndios para lançar novos recursos imediatamente.

Define precedente

Se você estiver muito disposto a trabalhar, seus colegas Dev terão incentivos para sobrecarregá-lo com ainda mais trabalho, às vezes mudando as tarefas operacionais que deveriam ser desempenhadas pelos Devs para SRE. Outras equipes também podem começar a esperar que os SREs realizem esse trabalho, o que é ruim por razões óbvias.

Promove atrito

Mesmo que você não esteja pessoalmente infeliz com o toil, seus atuais ou futuros companheiros de equipe podem gostar muito menos. Se você construir muito trabalho nos procedimentos de sua equipe, você motiva os melhores engenheiros da equipe a começar a procurar em outro lugar por um trabalho mais gratificante.

Causa violação de fé

As novas contratações ou transferências que ingressam na SRE com a promessa de um projeto de trabalho se sentirão enganadas, o que é ruim para o moral.

Conclusão

Se todos nós nos comprometermos a eliminar um pouco de trabalho a cada semana com alguma boa engenharia, iremos continuamente limpar nossos serviços e podemos mudar nossos esforços coletivos para a engenharia em escala, arquitetando a próxima geração de serviços e construindo SRE cruzado conjuntos de ferramentas. Vamos inventar mais e trabalhar menos.

Fonte

Escrito por Vivek Rau
Editado por Betsy Beyer
Traduzido por

Marcos RochaFollow

Meu nome é Marcos Rocha. Os artigos aqui escritos tem como objetivo de ajudar, documentar e sedimentar novos conhecimentos. Seja bem vindo!

Texto Original:
Eliminating Toil Written by Vivek Rau and Edited by Betsy Beyer

Disclaimer

Princípios de Design da Apple para iOS

Pedro Calado — Mon, 22 Nov 2021 17:57:27 +0000

Por trás de todo bom aplicativo no ecossistema da Apple, que possuem excelente user experience, estão boas práticas e padrões de design fornecidos pela própria Apple para cada um dos seus dispositivos, o Human Interface Guidelines (HIG). Desde o design dos ícones até a interação dos usuários com objetos de realidade aumentada, a ideia do HIG é fornecer padrões para que o time de produto como um todo, desde designers até desenvolvedores, consiga entregar produtos extraordinários, que os usuários gostem de usar, que sejam bonitos e simples ao mesmo tempo.

Neste artigo, vamos tratar especificamente do guia de design para iOS, trazendo um overview dos princípios do guia e alguns pontos essenciais que temos que levar em consideração ao projetarmos nossas aplicações.

O que faz o iOS ser único na visão da Apple

Existem 3 princípios que norteiam e diferenciam o iOS das demais plataformas de acordo com a Apple:

Clareza

O foco do design deve ser em guiar o usuário de maneira simples e intuitiva. Textos legíveis, ícones precisos, adornos sutis e apropriados, tendo como fim principal a funcionalidade, todas essas características fazem o iOS ser diferente. Quando você precisa enviar uma mensagem, compartilhar uma foto ou até mesmo saber se uma funcionalidade está ativa ou não, você consegue facilmente identificar o que cada ícone faz, trazendo clareza para o usuário.
Deferência

Se olharmos o significado da palavra deferência no dicionário, encontraremos algo como "atitude de respeito e consideração a um superior ou a pessoa mais velha". E aqui a ideia é exatamente essa: o design deve realçar o conteúdo, sendo este o mais importante e o que deve ser destacado. O design deve "trabalhar" para o conteúdo. Como exemplo, quando temos um fundo borrado, o conteúdo que não está borrado é pra onde nosso foco vai, fazendo com que foquemos no que realmente importa.
Profundidade

A ideia aqui é que sua aplicação seja dividida em camadas, tendo uma certa hierarquia que facilita o usuário ao navegar pelas informações, com transições entre telas que forneçam um senso de profundidade e permitam que o usuário acesse funcionalidades sem perder o contexto.

Princípios de Design

Integridade Estética

Esse ponto se refere ao quão bem a aparência e comportamento de um app se comunica com a sua funcionalidade. Uma aplicação crítica, como, por exemplo, que faz o controle de um sistema aéreo, deve focar em ter comportamentos previsíveis, evitando inserir elementos essencialmente estéticos que só trarão ruídos e não acrescentarão funcionalidade. Já uma aplicação mais imersiva como um jogo, por exemplo, deve possuir uma aparência mais cativante e até usar comportamentos imprevisíveis, permitindo que o usuário faça descobertas enquanto usa o app.

Consistência

Consistência se refere a fazer com que o app funcione da maneira com que o usuário espere que ele se comporte, trazendo padrões de gestos familiares, usando elementos já fornecidos pelo sistema, ícones (como ícones de lixeira, compartilhamento, etc.) e palavras conhecidas. De maneira geral, os usuários de smartphones já adquiriram hábitos de utilização que são difíceis de mudar, então devemos ao máximo tentar manter esses comportamentos.

Manipulação Direta

O ponto aqui é fazer com que o usuário possa ver alterações imediatas ao interagir com o app, seja rotacionando o celular ou interagindo com gestos e toques no conteúdo da tela.

Feedback

O feedback corresponde a manter os usuários informados sobre suas ações como, por exemplo, por meio de indicadores de progresso do download de arquivos, sons, alertas e a vibração do celular que ajuda o usuário a identificar o resultado de suas interações com o dispositivo e suas aplicações.

Metáforas

Metáforas são como uma digitalização de algo da vida real. Desde ícones dos apps, como o ícone do app de e-mail que representa uma carta, até aplicativos como o de gravação de áudio que simula as frequências conforme a intensidade do som gravado.

Controle do Usuário

A ideia aqui é que o usuário esteja no comando, e não os apps. As aplicações devem guiar o usuário, alertar sobre erros, dar feedback, mas nunca ter o controle. Por exemplo, uma aplicação que requer o uso da localização, como o Google Maps, solicitará ao usuário permissão para usar esse dado, explicando a necessidade dessa utilização. Com isso, o usuário está no controle, o que dá ao app certa confiabilidade.

Conclusão

Esses são os princípios que guiam o design dos produtos da Apple e o que fazem, de acordo com eles, o iOS diferente das demais plataformas em termos de user experience. No meu ponto de vista, ficou claro que o usuário é ponto principal em tudo o que fazem, mantendo-o no centro das decisões e fornecendo ferramentas que vão facilitar o uso das aplicações e trazer conforto e confiança.

.ltag__user__id__743191 .follow-action-button { background-color: #000000 !important; color: #ffffff !important; border-color: #000000 !important; }

Pedro CaladoFollow

Software Developer 👨🏻‍💻 | Always learning and sharing.

Disclaimer

C#10 e ASP.NET 6, oque esperar dessa dupla?

Lucas Paes — Thu, 04 Nov 2021 20:15:43 +0000

A Microsoft já anunciou que o lançamento do .Net6 está previsto para novembro de 2021, ou seja, para o próximo mês (ebaaa! 😊), pretendendo lançar uma nova versão todo ano nesta mesma data, como pode ser observado no cronograma abaixo.

Por conta dessa constante inovação da plataforma a empresa tende a realizar "poucas mudanças" e continuar com o suporte LTS de três anos, possibilitando migrações continuas de seus usuários para as novas atualizações de maneira mais fácil.

Mais informações: Microsoft: Política de suporte .NET

> Ok, mas cadê as novidades? 🤔

Alguns dos principais pontos que chegaram com a nova versão estão elencados aqui, caso queria se aprofundar no assunto recomendo visualizar as postagens do Daniel Roth dentro do portal da Microsoft.

Documentação e Posts sobre atualizações: Daniel Roth

Minimal Api/hosting: Está é a grande novidade que vai facilitar em muito a construção de pequenos Endpoints e melhorar a performance em geral do warm-up (tempo de "aquecimento") para as Apis, esse ponto foi levado em consideração pela Microsoft pelo fato do BOOM do Serverless + functions que necessitam de um desempenho de inicialização maior. A Startup.cs "Morreu" 😥 e agora o Program.cs "faz tudo", sendo possível desenvolver apenas com ele, sim, com cara de Node.Js. Segue exemplo dos novos endpoints:

Github com exemplo de uso: DamianEdwards/MinimalApiPlayground


using System.ComponentModel.DataAnnotations;
using Microsoft.Data.Sqlite;
using Dapper;

var builder = WebApplication.CreateBuilder(args);

var connectionString = builder.Configuration.GetConnectionString("TodoDb") ?? "Data Source=todos.db";
builder.Services.AddScoped(_ => new SqliteConnection(connectionString));
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

app.MapPut("/todos/{id}/mark-incomplete", async (int id, SqliteConnection db) =>
    await db.ExecuteAsync("UPDATE Todos SET IsComplete = false WHERE Id = @Id", new { id }) == 1
        ? Results.NoContent()
        : Results.NotFound())
    .WithName("MarkIncomplete")
    .Produces(StatusCodes.Status204NoContent)
    .Produces(StatusCodes.Status404NotFound);

app.MapDelete("/todos/{id}", async (int id, SqliteConnection db) =>
    await db.ExecuteAsync("DELETE FROM Todos WHERE Id = @id", new { id }) == 1
        ? Results.NoContent()
        : Results.NotFound())
    .WithName("DeleteTodo")
    .Produces(StatusCodes.Status204NoContent)
    .Produces(StatusCodes.Status404NotFound);

MiniValidator / Metadata: Com a chegada do conceito de Minimal Api o .Net6 também traz uma validação mais enxuta e performática, a biblioteca MiniValidator é uma versão minimalista dos DataAnnotations que adiciona suporte para as chamadas de validação de linha única e recursão com detecção de ciclo. E para fechar a concepção de Minimal foi desenvolvida diversas Metadatas para facilitar a documentação e estruturação dos novos recursos, como demostrado no exemplo a seguir.

app.MapPost("/todos", async (Todo todo, SqliteConnection db) =>
    {
            //Realiza a validação da DTO
        if (!MiniValidator.TryValidate(todo, out var errors))
            return Results.ValidationProblem(errors); 

        var newTodo = await db.QuerySingleAsync<Todo>(
            "INSERT INTO Todos(Title, IsComplete) Values(@Title, @IsComplete) RETURNING * ", todo);

        return Results.Created($"/todos/{newTodo.Id}", newTodo);
    })
    .WithName("CreateTodo") //Define nome para o endpoint
    .ProducesValidationProblem()
    .Produces<Todo>(StatusCodes.Status201Created) // Documenta o retorno;

Suporte a HTTP/3: A Microsoft já introduziu nativamente o suporte a nova versão do nosso conhecido e querido protocolo de transferência, que por sua vez promete manter os padrões atuais e atribuir mais desempenho por meio do uso QUIC, visando tirar o bloqueio das transações em paralelo quando um pacote era "perdido".

Mais informações: HTTP/3 Support in .NET 6

Hot Reload: Este é um recurso muito bacana para nós desenvolvedores pois permite atualizar o código em tempo real sem perder o estado da aplicação, auxiliando em muito as validações UI e funcionando também com o dotnet watch run no VSCode, já para o Visual Studio basta clicar sobre o ícone de "Fogo 🔥" na parte superior depois de realizar alguma mudança.

Mais informações: Introducing the .NET Hot Reload experience for editing code at runtime

Blazor / .NET MAUI / SPA: A nova sensação do front que virá com o .Net6 é o MAUI que tem o foco em criar Apps com visuais mais modernos e compartilhando mais código entre as plataformas, ao longo do tempo ele será compatível com macOS e Windows, mas no momento o suporte é para Android e iOS. Também é importante mencionar a chegada da biblioteca ´Xamarin.Essentials´ que possibilita acessar recursos nativos dos dispositivos, como sensores, armazenamentos e afins. Já para o SPA agora é possível separar o front-end do back-end em dois projetos e foi acrescentado o ecossistema de estruturas JavaScript SPA no Visual Studio, com teste de unidade, gerenciamento de GUI npm, modelos baseados em CLI e mais novidades a serem anunciadas.

Mais informações: ASP.NET Core updates in .NET 6 Release

Using Global: Sim, ISSO MESMO!!🥳 Agora é possível definir usings globalmente, basta acrescentar a palavra global antes de declarar o using, muito útil quando usado em conjunto com arquivos de configuração geral da aplicação, permitindo que todos os outros arquivos possuam acesso aos usings.

global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;

File-scoped namespace declaration: Agora é possível declarar os namespaces de sua aplicação sem abrir e fechar as chaves, basta colocar um ; (ponto e virgula) no final, como no exemplo abaixo.

namespace MyNamespace;

Extended property patterns: O novo C#10 já está apto para trabalhar com referência a propriedades ou campos aninhados em uma propriedade, como pode ser visto abaixo.

{ Prop1: { Prop2: pattern } } // Antiga maneira
{ Prop1.Prop2: pattern } // Nova maneira

LINQ / CHUCK / MetodosBy: Chegou também melhorias para os métodos OrDefault do Linq e afins, agora sendo possível definir no próprio método um valor default, um ponto muito interessante foi a vinda do IEnumerable Chunk para facilitar a paginação e manipulação de dados, em conjunto com diversos métodos *By para utilização de listas.

var list = Enumerable.Range(1, 100);
foreach(var chunk in list.Chunk(10))
  foreach(var item in chunk) 
    Console.WriteLine(item);

var foundValue = hayStack.FirstOrDefault(x => x == needle, -1);

Console.Write(people.MaxBy(x => x.Age));

Mais informações: .NET 6 / C# 10 Top New Features Recap

> Legal, mas existe algo para chegar ainda?

A Microsoft sempre tem projetos "escondidos" que estão sendo trabalhados por baixo dos panos para criar grandes mudanças na sua plataforma, aqui citarei dois desses projetos que estão sendo desenvolvidos para as próximas versões do .Net, o Houdini e o Bedrock.

Projeto Houdini: A Microsoft quer modificar a sua Stack para deixa-la mais performática, e esse projeto vem com tudo para cima do MVC, com foco em ACABAR com ele, e tirar todo o peso que seus componentes geram para as Apis e afins.

Mais informações: The .NET Stacks, #28: The future of MVC and themes of .NET 6

Projeto BedRock: Visando novamente a alta performance da plataforma, esse projeto tem o intuito de abstrair toda a camada de comunicação cliente-server, de forma que o .Net vai verificar as opções disponíveis e escolher a melhor forma de realizar essa troca de dados dependendo do ambiente e da situação. Esse projeto possui três pilares (transporte, middleware e protocolo) e será usado pelo IConnectionFactory e IConnectionListener.

Mais informações: BedrockFramework

> Por enquanto é isso, obrigado! ✌️

Qualquer dúvida pode me chamar para um bate-papo, e agradeço a sua atenção até aqui, espero te ver em outras publicações.

Lucas PaesFollow

Brasileiro, 22 anos. Amo tecnologia e estou sempre explorando novos conhecimentos.

Disclaimer

Criando uma Web API com .NET Core, EntityFramework Core - Número Cartão de Crédito Aleatório

Matheus Paixão — Mon, 18 Oct 2021 21:07:29 +0000

Este projeto irá te guiar no Passo a Passo de como criar uma Web API aplicando os conceitos REST em .NET Core, usando Entity Framework.

Pré-requisitos:

Visual Studio 2019 com pacotes de ASP.NET e desenvolvimento web instalados
.NET Core 3.1
Postman

O Projeto:

Desenvolver uma aplicação Web API com .NET Core, EntityFramework Core usando arquitetura REST.

A API deverá gerar números aleatórios para o pedido de um novo cartão de crédito virtual. Cada cartão gerado deve estar associado a um email para identificar a pessoa que está utilizando.

EndPoints

GET
Listar todos os números de cartão de crédito indexados a um email fornecido em forma de parâmetro pelo cliente.

POST
Cadastrar email

Gerar Número de cartão de crédito aleatório.

Indexar email criado a Número de cartão gerado.

Mostrar número de cartão gerado ao final da operação.

Relacionamentos

É de extrema importância entender e modelar o projeto em questão antes de avançar para os códigos.

Esse projeto pode ser feito com apenas uma classe, uma tabela de dados, pois são apenas 2 informações coletadas e o relacionamento exigido permite isso.

Classe: ClienteDados

Atributos

int Id
string Email
string CardNumber

A chave primária dessa classe é o ID, pois será uma forma de indexar o e-mail a seu respectivo cartão de crédito e também porque o atributo Email não poderia ser chave primária pois chave primária não pode ser repetir e podemos ter vários emails iguais.

Podemos 1 email com vários cartões de crédito (Email 1 para * muitos Cartões de crédito), porém podemos ter apenas 1 email por cartão de crédito, esse é o relacionamento de dados entre os atributos.

Agora que compreendemos o que o projeto pede, mãos à obra.

Digite o nome do projeto e clique em Proximo.

Em informações adicionais selecione “.NET Core 3.1 (suporte de longo prazo)” e clique em Criar.

Instalar pacotes de NuGet

Para instalar o suporte EF Core a um projeto, vá em Gerenciar Pacotes de NuGet para a Solução, para instalar os pacotes necessários para esta API.

Os pacotes a serem instalados são:
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.InMemory
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer

Para instalar, digite o nome do pacote em Procurar, selecione o pacote, selecione o nome do seu projeto e clique em instalar.

Criar Models e Classes

O projeto vem com uma classe e um Controller de exemplos, os WeatherForecast.cs. Exclua esses dois arquivos pois não vamos usá-los.

Agora vamos criar nosso Modelo e nossa Classe ClienteDados.

Criar uma pasta chamada Models, clicando com o botão direito no nome do projeto clique em Adicionar > Pasta. Nomear de Models. Models é onde armazenamos nossas classes.

Dentro da pasta Models criar uma Class chamada ClienteDados. Clicando com o botão direito na pasta Models e depois clique em Adicionar > Classe. Nomear ClienteDados e criar.

Agora declare os atributos que usaremos neste projeto.

namespace APICartaoDeCredito.Models
{
    public class ClienteDados
    {
        public int Id {get; set;}
        public string Email {get; set;}
        public string CardNumber {get; set;}
    }   
}

Construir o contexto de Banco de Dados

Criar a pasta de banco de dados chamada DataBase e dentro dessa parte criar a nossa classe de contexto a ApiContext.cs. Essa classe é a responsável principal pela comunicação com a Entity Framework Core

Dentro dessa classe, vamos criar o nosso InMemory Data Base, que será nosso banco de dados em memória.

Carregue os pacotes que usaremos nessa classe.
using Microsoft.EntityFrameworkCore;
using ApiCartaoDeCredito.Models;

Olhando o Código pronto abaixo, temos ClientesDb que será nossa propriedade DbSet de acesso ao banco de dados.

Dentro da classe ApiContex seria onde podemos definir regras de relacionamento, definir quem é chave primária entre outras coisas relacionadas a Banco de Dados, mas não será necessário nesse projeto.

public class ApiContex : DbContext

    {
        public ApiContex(DbContextOptions<ApiContex> options) : base(options)
        {

        }
        public DbSet<ClienteDados> ClientesDb { get; set; }
    }
}

Criar registro do ApiContex

No projeto tem uma classe que foi criada com a criação do projeto que precisamos registrar o banco de dados que criamos. Abra a classe Startup.cs e procure o método ConfigureServices() e adicione essa linha de código.

public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext<ApiContex>(opt =>
            opt.UseInMemoryDatabase("ClienteDb"));

            services.AddControllers();
        }

Criar Controllers

Clicar com botão direito na pasta Controllers > Adicionar > Novo Item Scaffold. Na janela que abrir selecione Controlador API com ações, usando o Entity Framework, depois clique em Adicionar.

Na janela que abrir, temos que escolher para qual classe estamos criando nossa Controller. Selecione ClienteDados. Logo abaixo tem a opção da classe de contexto de dados, que é a classe ApiContext, que criamos para ser nossa classe de controle do banco de dados.
Escolher o nome do Controller, mas de default Visual Studio já nos fornece o nome apropriado.
Agora clique em Adicionar.

Usar o Scaffold para criar os Controllers, nos dá o benefício de que eles já criam automaticamente os métodos REST, que são os vistos na imagem abaixo. GET PUT POST e DELETE.

GET: Método onde vamos extrair informações do banco de dados e exibi-los.
PUT: Método que altera informações do banco de dados
POST: Método para adicionar informações no banco de dados.
DELETE: Método para deletar informações do banco de dados.

Lembrando das exigências que vimos anteriormente, neste projeto usaremos apenas o método GET e POST.

Método POST

Id - Gerada automaticamente (Chave primária, gerada automaticamente pelo sistema)
Email - Adicionado pelo usuário.
CardNumber - Gerado automaticamente de forma aleatória.

No método POST adicione as linhas de código abaixo.

    public async Task<ActionResult<ClienteDados>> PostClienteDados(ClienteDados clienteDados)
    {        
        Random rnd = new Random();
        int ccn1 = rnd.Next(1000, 9999);
        int ccn2 = rnd.Next(1000, 9999);
        int ccn3 = rnd.Next(1000, 9999);
        int ccn4 = rnd.Next(1000, 9999);
        clienteDados.CardNumber = $"{ccn1} {ccn2} {ccn3} {ccn4}";

        _context.ClientesDb.Add(clienteDados);  
            await _context.SaveChangesAsync();
            return CreatedAtAction("PostClienteDados", new { clienteDados = clienteDados.CardNumber }, clienteDados.CardNumber);
    }

Random rnd - Para gerarmos números aleatórios crie uma instância da classe Random para acessarmos as funções desta classe.
Como não foi especificado no nosso projeto a bandeira do cartão de crédito ou quantos números teria, então decidi que neste projeto serão 4 blocos de 4 números aleatórios.

int ccn1/2/3/4 - Estas 4 variáveis são os 4 blocos de 4 números.
Para gerarmos de fato os números aleatórios precisamos chamar a função next da classe Random, através da instância rnd. rnd.Next. Dentro da função Next definimos o range de números que queremos.

rnd.Next(1000, 9999);

Agora que temos os números criados, precisamos armazená-los dentro do nosso atributo que representa o número do cartão de crédito no nosso banco de dados, o CardNumber.
Precisamos então concatenar as 4 variáveis ccn para armazená-las em CardNumber.

clienteDados.CardNumber = $"{ccn1} {ccn2} {ccn3} {ccn4}"

Aqui usamos a nossa instância (clienteDados) da classe (ClienteDados) do projeto para acessar o atributo CardNumber.

Bom, já temos nosso número aleatório de cartão de crédito, agora precisamos armazenar tudo no banco de dados.

_context.ClientesDb.Add(clienteDados);
        await _context.SaveChangesAsync();

Usamos a nossa instância do nosso contexto do banco de dados _context.ClientesDb para acessar o banco de dados e executar a função .Add para ADICIONAR informação da classe ClienteDados.
E toda vez que adicionamos algo ao banco de dados precisamos salvar através da função .SaveChangesAsync();

O projeto pede que após o usuário inserir o seu email, o sistema vai retornar apenas o número de cartão de crédito. Para isso vamos usar o código abaixo.

            return CreatedAtAction("PostClienteDados", new { clienteDados = clienteDados.CardNumber }, clienteDados.CardNumber);

Se atentar para o método que está sendo chamado, que é o PostClienteDados e para o que vem após de new, pois deve ser o mesmo parâmetro da função PostClienteDados. Para filtrar e mostrar apenas CardNumber é necessário que especifique clienteDados.CardNumber.

Método GET

O projeto pede que quando o usuário insere o seu e-mail como parâmetro, retorne em ordem de criação apenas os números de cartão de crédito.

Antes do método GET precisamos criar um TYPE, para ter acesso aos atributos da nossa classe.

    public class NEW_TYPE
    {
        public string Cartao { get; set; }
    };

     // GET: api/ClienteDados/”inserir email aqui”
    [HttpGet("{email}")]
        public async Task<ActionResult<IEnumerable<ClienteDados>>> GetEmail(string email)
        {
            var list = from a in _context.ClientesDb
                        where a.Email.Equals(email)
                        select new NEW_TYPE
                        {
                            Cartao = a.CardNumber
                        };
            var CartoesdeCredito = await list.ToListAsync();
            return Ok(CartoesdeCredito);
        }

Repare que agora o [HttpGet] está com um complemento, que é o parâmetro que o usuário vai inserir [HttpGet(“{email}”).

Como estamos recebendo um parâmetro, precisamos receber em uma variável, por isso temos (string email) após a declaração do método.

public async Task>> GetEmail

Crie uma instância do nosso banco de dados.

var list = from a in _context.ClientesDb

Crie uma estrutura de consulta com filtro.

var list = from a in _context.ClientesDb
where a.Email.Equals(email)
select new NEW_TYPE
{
Cartao = a.CardNumber
};

Agora que temos a informação filtrada, vamos adicionar a uma lista.

var CartoesdeCredito = await list.ToListAsync();

E retornaremos a lista para o usuário.

return Ok(CartoesdeCredito);

Roteamento

Antes de testarmos nossa API precisamos atualizar o arquivo launchSettings.json adicionando a rota do URL que desejamos acessar nossa API

 "profiles": {
"IIS Express": {
  "commandName": "IISExpress",
  "launchBrowser": true,
  "launchUrl": "api/ClienteDados",
  "environmentVariables": {
    "ASPNETCORE_ENVIRONMENT": "Development"
  }
},
"APICartaoDeCredito": {
  "commandName": "Project",
  "launchBrowser": true,
  "launchUrl": "api/ClienteDados",
  "applicationUrl": "https://localhost:5001;http://localhost:5000",
  "environmentVariables": {
    "ASPNETCORE_ENVIRONMENT": "Development"
  }

Atualize o parâmetro “launchUrl” e coloque o caminho desejado, no nosso caso vai ser o api/ClienteDados.

Na parte superior desse arquivo você pode escolher a porta do localhost a ser usada.

Caso você queira personalizar a URL, você deve se atentar para mudar o roteamento no Controller também, pois ele vem como de Defaut roteando para api/nome da classe e se você inicializar com outro nome, deve especificar no Controller.

Postman

Por conveniência, escolhi a plataforma Postman para realizar os testes do projeto, existem outras formas e plataformas para testar.

Ao abrir o Postman clique em Create New para criar um novo projeto, e na próxima janela que abrir escolha HTTP Request.

Na próxima janela que abrir clique em New Collection, dê um nome pra ela, e clique em Create, na próxima janela clique em Save e pronto, projeto criado.

De volta ao Visual Studio, na barra superior de ferramentas, no símbolo de PLAY para executar nosso projeto.

O seu navegador padrão deverá abrir no endereço que roteamos no projeto.

https://localhost:44340/api/ClienteDados

Lembrando que a porta do URL pode ser diferente.

Pegue esse link e cole no Postman.

Você deve receber Status 200 OK que significa que a requisição retornou com sucesso.

Como não demos nenhuma entrada até esse momento, ele retornou tudo em branco.

Endpoint 1

Para realizarmos a primeira entrada, clique no Dropdown menu onde está escrito GET e aparecerá todos os verbos disponíveis de Http para você escolher.

Clique em Post para acessarmos o método Post do nosso projeto.
Clique em Body, depois em raw, depois troque o método de entrada de Text para JSON.

O código para darmos a primeira entrada no banco de dados, inclui apenas Email, pois as outras informações são geradas automaticamente.

{
"Email": "digite o email aqui"
}

Após digitar o email desejado clique em Send para executar o código e o sistema retornará 200 OK e o número de cartão de crédito gerado.

Para fazer o teste do segundo Endpoint, crie vários números para o mesmo email.

Endpoint 2

Mude o verbo Http no Postman para GET novamente.
E no caminho URL adicione o email cadastrado e clique Send novamente.

https://localhost:44340/api/ClienteDados/EmailCadastradoAQUI

E o sistema retornou os cartões de crédito que pertencem ao usuário do email cadastrado, e listou-os em ordem de criação.

É possível testar o método GET no browser também, digitando o caminho do URL+email https://localhost:44340/api/ClienteDados/emailcadastrado e ele dará o mesmo retorno que no Postman.

Com isso concluímos este projeto. https://github.com/mgpaixao/APICartaoDeCredito

Obrigado

Matheus PaixãoFollow

Gosto de compartilhar conhecimento pois foi assim que eu aprendi a programar. O meu negócio é todo dia saber mais que eu sabia ontem. Pode me chamar, vamos aprender juntos. Prazer =)