Shared posts

19 Feb 03:10

PacketTotal – Análise Online de arquivos .pcap e pcapng

by Marcos Henrique

O PacketTotal é uma solução web que analisa arquivos .pcap, .pcapng a fim de visualizar o tráfego de coletado, identificando tráfego malicioso, e informações detalhadas e filtradas dos pacotes.

Acesse: www.packettotal.com

01 Passo

Utilize o Wireshark para realizar a captura dos pacotes e salve o arquivo: (ex: 100SECURITY.pcap)

02 Passo

Acesse o site www.packettotal.com e clique em Browse para realizar o upload o arquivo.

03 Passo

O upload foi realizado, clique em OK

04 Passo

Clique em Analyze! e confirme o código CAPTCHA

 

05 Passo

Todas as informações do pacote são exibidas!

Observações:

No menu Statitcs você encontra um painel de indicadores dos tipos de pacotes já analisados pelo PacketTotal.

06 Dec 13:49

Essas 13 coisas inesperadas podem te levar preso em outros países

by Luciana Calogeras

Muitas pessoas chegam em um país estrangeiro e muitas vezes têm uma surpresa desagradável de serem punidas pelas autoridades por algo que seria completamente comum em seu país em questão.

Algumas situações podem de fato colocar um turista em uma situação perigosa, uma vez que as regras são levadas à risca em muitos locais. Veja só as 13 coisas inesperadas podem te levar preso em outros países:

1 – Comprar álcool após o almoço na Tailândia

A Tailândia tem sido conhecida por seus clubes e encontros. Particularmente é famosa pelas festas em toda lua cheia na ilha de Pangan. No entanto, muitos turistas simplesmente não sabem que a compra de álcool no país é proibida das 14:00 às 17:00.

Isso significa que você não pode encher a cara de rum na praia às 3 horas da tarde, no maior estilo capitão Jack Sparrow. Caso qualquer funcionário de um clube, bar ou loja seja visto vendendo álcool durante uma sesta, o mesmo será multado em 4.000 baht (quase R$ 400) ou pode ser preso por até 2 anos.

2 – Teclar enquanto anda é ilegal em Honolulu

Esta proibição completamente nova foi introduzida na capital do Havaí para treinar os pedestres a serem cautelosos e não se distraírem enquanto andam pelas ruas.

Se você for visto enviando mensagens de texto ou mexendo em qualquer dispositivo eletrônico enquanto atravessa a rua, não se ofenda com uma multa de US $ 99.

3 – É proibido discotecas após a meia noite no Japão

Essa restrição legislativa estranha veio quando as autoridades japonesas as introduziram em 1948 para limitar o crescimento da indústria do sexo.

Em 2015, houve uma brecha para a lei: agora as danças após a meia-noite são permitidas, mas apenas com uma iluminação mínima de 10 lx (10 lumens por metro quadrado).

4 – Fumar em lugares públicos em Cingapura

Embora fumar em lugares públicos em Cingapura não seja proibido, há restrições rigorosas sobre onde exatamente você pode fumar.

É estritamente proibido fumar em pontos de ônibus, playgrounds e estacionamentos. Os fumantes também devem ficar a menos de 5 metros da entrada do prédio e das portas do ônibus, de modo a não ganharem uma multa de US $ 10.000.

5 – Fazer juramentos em locais públicos na Austrália

Nos estados australianos de Victoria, New South Wales e Queensland, há uma proibição de jurar em lugares públicos. Ainda mais se for algo desagradável em voz alta, você terá de pagar uma multa no valor de 100 a 140 dólares australianos.

6 – Atravessar a rua no lugar errado é proibido nos EUA

Nos Estados Unidos, Irã e Cingapura, atravessar a rua em qualquer lugar, exceto na faixa de pedestres, resultará em uma multa e uma convocação para o tribunal ou mesmo prisão. A probabilidade de ser atropelado é enorme, pois os motoristas dificilmente irão parar para que você finalize a travessia.

7 – Alimentar pombos em Veneza

É proibido alimentar os pombos em Veneza desde 2008. A razão é prosaica: quanto menor a população de pombos, menos danos de seus excrementos sofrerão os monumentos famosos e obras-primas arquitetônicas.

8 – Andar de roupas de banho em algumas cidades praianas da Espanha

Nas praias você pode usar suas roupas de banho, porém não nas cidades. Caso faça isso, você deve dizer adeus a uma quantia no valor de 100 a 200 euros.

9 – Uso de analgésicos nos Emirados Árabes Unidos

As leis sobre a regulamentação da indústria farmacêutica nos Emirados são incrivelmente difíceis – muitos medicamentos que são vendidos sem receita médica em todo o mundo são consideradas drogas fortes, especialmente contendo codeína.

Se você está voando para os Emirados Árabes Unidos, não leve paracetamol com você, pois apenas pelo seu porte, você pode ter problemas gravíssimos com a legislação, como por exemplo ser condenado a 4 anos de prisão.

10 – Calçados de salto alto em locais de atrações históricas na Grécia

A lei foi aprovada em 2009 e tem seus próprios motivos: a arquitetura antiga se desgasta muito se não for tratada com cuidado.

11 – Dirigir com os faróis desligados na Suécia

Na Suécia na Noruega os motoristas são obrigados a ligar as luzes durante o trânsito, tanto à noite como durante o dia.

Isso se deve ao fato de que, no inverno, a visibilidade em Estocolmo é limitada em apenas 5-6 horas de luz do dia. A medida foi tomada para reduzir o risco de acidentes.

12 – Parar nas estradas na Alemanha

A rede alemã de rodovias regula rigorosamente o tráfego, sem parar. Os motoristas que provocam engarrafamentos por suas paradas podem receber uma multa de 30 a 70 euros.

Em alguns países é comum as paradas deliberadas, atrapalhando o fluxo do trânsito.

13 – Usar calças ou shorts rosa aos domingos em Victoria, Austrália

As raízes desta lei estranha que proíbe o uso de calças rosa à tarde se deram na era vitoriana. Seus motivos são desconhecidos para qualquer um, mas se você for dar um passeio após o jantar com este item do guarda-roupa, você será acusado de cometer um crime.

Vai entender!

[Ofigenno]

O post Essas 13 coisas inesperadas podem te levar preso em outros países apareceu primeiro em Mistérios do Mundo.

30 Nov 19:12

Angular 5 vem com compilação incremental mais rápida

by Abel Avram

O Google lançou o Angular 5, incluindo otimizações de build, compilação incremental, e um suporte melhor para internacionalização, dentre outras melhorias.

By Abel Avram Translated by Eduardo Kuwakino
30 Nov 12:43

Introducing AWS Fargate – Run Containers without Managing Infrastructure

by Randall Hunt

Containers are a powerful way for developers to develop, package, and deploy their applications. At AWS we have over a hundred thousand active ECS clusters and hundreds of millions of new containers started each week. That’s 400+% customer growth since 2016. Container orchestration solutions, like Amazon ECS and Kubernetes make it easier to deploy, manage, and scale these container workloads increasing your agility. However, with each of these container management solutions you’re still responsible for the availability, capacity, and maintenance of the underlying infrastructure. At AWS we saw this as an opportunity to remove some undifferentiated heavy lifting. We want to let you take full advantage of the speed, agility, and immutability that containers offer so you can focus on building your applications rather than managing your infrastructure.

AWS Fargate

AWS Fargate is an easy way to deploy your containers on AWS. To put it simply, Fargate is like EC2 but instead of giving you a virtual machine you get a container. It’s a technology that allows you to use containers as a fundamental compute primitive without having to manage the underlying instances. All you need to do is build your container image, specify the CPU and memory requirements, define your networking and IAM policies, and launch. With Fargate, you have flexible configuration options to closely match your application needs and you’re billed with per-second granularity.

The best part? You can still use all of the same ECS primitives, APIs, and AWS integrations. Fargate provides native integrations with Amazon Virtual Private Cloud, AWS Identity and Access Management (IAM), Amazon CloudWatch and load balancers. Fargate tasks use the AWSVPC networking mode and provision an Elastic Network Interface (ENI) in your VPC to communicate securely with your resources. With the AWS Command Line Interface (CLI) launching a Fargate task is simple.

ecs run-task --launch-type FARGATE --cluster BlogCluster --task-definition blog --network-configuration "awsvpcConfiguration={subnets=[subnet-b563fcd3]}"

It’s also easy to use the console to create task definitions and run tasks with the Fargate launch type.

Once we’ve launched a few tasks we can see them running in our cluster:

You’ll notice that ECS clusters are heterogeneous. They can contain tasks running in Fargate and on EC2.

If we dive a little deeper and look at a task we can see some useful information including the ENI that Fargate provisioned in our VPC and all of the containers used by that task. The logs tab gives me easy access to my CloudWatch Logs for that task as well.

Let’s take a look at the configuration options and pricing details for Fargate.

Pricing

AWS Fargate uses an on-demand pricing model. You pay per per-second for the amount of vCPU and memory resources consumed by your applications. Price per vCPU is $0.00084333 per second ($0.0506 per hour) and per GB memory is $0.00021167 per second ($0.0127 per hour). With Fargate you have 50 configuration options for vCPU and Memory to support a wide range of workloads. The configuration options are below.

 

CPU (vCPU) Memory Values (GB)
0.25 0.5, 1, 2
0.5 1, 2, 3
1 Min. 2GB and Max. 8GB, in 1GB increments
2 Min. 4GB and Max. 16GB, in 1GB increments
4 Min. 8GB and Max. 30GB in 1GB increments

Things To Know

  • You can configure Fargate to closely meet your application’s resource requirements and pay only for resources required by your containers. You can launch tens or tens of thousands of containers in seconds.
  • Fargate tasks run similarly to tasks running on EC2. You can add them to VPCs, configure load balancers, and assign IAM roles.

On the Roadmap

I won’t spill all the beans, but we have a really exciting roadmap for AWS Fargate. I will tell you that we plan to support launching containers on Fargate using Amazon EKS in 2018. As always, we love your feedback. Please leave a note in the Amazon ECS forum letting us know what you think.

Fargate is available today in the US East (Northern Virginia) region.

Randall

30 Nov 12:42

Amazon Elastic Container Service for Kubernetes

by Jeff Barr

My colleague Deepak Singh has a lot to say about containers!

Jeff;


We have a lot of AWS customers who run Kubernetes on AWS. In fact, according to the Cloud Native Computing Foundation, 63% of Kubernetes workloads run on AWS. While AWS is a popular place to run Kubernetes, there’s still a lot of manual configuration that customers need to manage their Kubernetes clusters. You have to install and operate the Kubernetes master and configure a cluster of Kubernetes workers. In order to achieve high availability in you Kubernetes clusters, you have to run at least three Kubernetes masters across different AZs. Each master needs to be configured to talk to each, reliably share information, load balance, and failover to the other masters if one experiences a failure. Then once you have it all set up and running you still have to deal with upgrades and patches of the masters and workers software. This all requires a good deal of operational expertise and effort, and customers asked us to make this easier.

Introducing Amazon EKS
Amazon Elastic Container Service for Kubernetes (Amazon EKS) is a fully managed service that makes it easy for you to use Kubernetes on AWS without having to be an expert in managing Kubernetes clusters. There are few things that we think developers will really like about this service. First, Amazon EKS runs the upstream version of the open-source Kubernetes software, so you can use all the existing plugins and tooling from the Kubernetes community. Applications running on Amazon EKS are fully compatible with applications running on any standard Kubernetes environment, whether running in on-premises datacenters or public clouds. This means that you can easily migrate your Kubernetes application to Amazon EKS with zero code changes. Second, Amazon EKS automatically runs K8s with three masters across three AZs to protect against a single point of failure. This multi-AZ architecture delivers resiliency against the loss of an AWS Availability Zone.

Third, Amazon EKS also automatically detects and replaces unhealthy masters, and it provides automated version upgrades and patching for the masters. Last, Amazon EKS is integrated with a number of key AWS features such as Elastic Load Balancing for load distribution, IAM for authentication, Amazon VPC for isolation, AWS PrivateLink for private network access, and AWS CloudTrail for logging.

How it Works
Now, let’s see how some of this works. Amazon EKS integrates IAM authentication with Kubernetes RBAC (the native role based access control system for Kubernetes) through a collaboration with Heptio.

You can assign RBAC roles directly to each IAM entity allowing you to granularly control access permissions to your Kubernetes masters. This allows you to easily manage your Kubernetes clusters using standard Kubernetes tools, such as kubectl.

You can also use PrivateLink if you want to access your Kubernetes masters directly from your own Amazon VPC. With PrivateLink, your Kubernetes masters and the Amazon EKS service endpoint appear as an elastic network interface with private IP addresses in your Amazon VPC.

This allows you to access the Kubernetes masters and the Amazon EKS service directly from within your own Amazon VPC, without using public IP addresses or requiring the traffic to traverse the internet.

Finally, we also built an open source CNI plugin that anyone can use with their Kubernetes clusters on AWS. This allows you to natively use Amazon VPC networking with your Kubernetes pods.

With Amazon EKS, launching a Kubernetes cluster is as easy as a few clicks in the AWS Management Console. Amazon EKS handles the rest, the upgrades, patching, and high availability. Amazon EKS is available in Preview. We look forward to hearing your feedback.

— Deepak Singh, General Manager of AWS Container Services

30 Nov 11:45

Brasileiro Sendo Brasileiro

Brasileiro Sendo Brasileiro

Não precisava nem por na legenda da onde eles são, é visivel! hASuAHSuAHSuAHus

29 Nov 01:38

Traefik : Load balancer para containers

by fabio.reis

Neste post será apresentado como realizar a primeira configuração do Traefik. Traefik é um proxy reverso e load balancer para microservices que suporta: Docker, Swarm mode, Kubernetes, Marathon, Consul, Etcd, Rancher e Amazon ECS.     1) Ambiente : Neste primeiro post sobre o assunto será apresentado apenas um cenário simples escalando containers . 10.0.0.70 […]

O post Traefik : Load balancer para containers apareceu primeiro em FAJLINUX.

29 Nov 01:36

Amazon MQ – Managed Message Broker Service for ActiveMQ

by Jeff Barr

Messaging holds the parts of a distributed application together, while also adding resiliency and enabling the implementation of highly scalable architectures. For example, earlier this year, Amazon Simple Queue Service (SQS) and Amazon Simple Notification Service (SNS) supported the processing of customer orders on Prime Day, collectively processing 40 billion messages at a rate of 10 million per second, with no customer-visible issues.

SQS and SNS have been used extensively for applications that were born in the cloud. However, many of our larger customers are already making use of open-sourced or commercially-licensed message brokers. Their applications are mission-critical, and so is the messaging that powers them. Our customers describe the setup and on-going maintenance of their messaging infrastructure as “painful” and report that they spend at least 10 staff-hours per week on this chore.

New Amazon MQ
Today we are launching Amazon MQ – a managed message broker service for Apache ActiveMQ that lets you get started in minutes with just three clicks! As you may know, ActiveMQ is a popular open-source message broker that is fast & feature-rich. It offers queues and topics, durable and non-durable subscriptions, push-based and poll-based messaging, and filtering.

As a managed service, Amazon MQ takes care of the administration and maintenance of ActiveMQ. This includes responsibility for broker provisioning, patching, failure detection & recovery for high availability, and message durability. With Amazon MQ, you get direct access to the ActiveMQ console and industry standard APIs and protocols for messaging, including JMS, NMS, AMQP, STOMP, MQTT, and WebSocket. This allows you to move from any message broker that uses these standards to Amazon MQ–along with the supported applications–without rewriting code.

You can create a single-instance Amazon MQ broker for development and testing, or an active/standby pair that spans AZs, with quick, automatic failover. Either way, you get data replication across AZs and a pay-as-you-go model for the broker instance and message storage.

Amazon MQ is a full-fledged part of the AWS family, including the use of AWS Identity and Access Management (IAM) for authentication and authorization to use the service API. You can use Amazon CloudWatch metrics to keep a watchful eye metrics such as queue depth and initiate Auto Scaling of your consumer fleet as needed.

Launching an Amazon MQ Broker
To get started, I open up the Amazon MQ Console, select the desired AWS Region, enter a name for my broker, and click on Next step:

Then I choose the instance type, indicate that I want to create a standby , and click on Create broker (I can select a VPC and fine-tune other settings in the Advanced settings section):

My broker will be created and ready to use in 5-10 minutes:

The URLs and endpoints that I use to access my broker are all available at a click:

I can access the ActiveMQ Web Console at the link provided:

The broker publishes instance, topic, and queue metrics to CloudWatch. Here are the instance metrics:

Available Now
Amazon MQ is available now and you can start using it today in the US East (Northern Virginia), US East (Ohio), US West (Oregon), EU (Ireland), EU (Frankfurt), and Asia Pacific (Sydney) Regions.

The AWS Free Tier lets you use a single-AZ micro instance for up to 750 hours and to store up to 1 gigabyte each month, for one year. After that, billing is based on instance-hours and message storage, plus charges Internet data transfer if the broker is accessed from outside of AWS.

Jeff;

22 Nov 01:45

Lugares Ao Redor Do Mundo Antigamente VS Agora

Lugares Ao Redor Do Mundo Antigamente VS Agora

A evolução é linda, mas a conservação é algo fenomenal, muito massa!

20 Nov 13:18

Podcast Hipsters Ponto Tech – A linguagem Go

by Hipsters Ponto Tech

Go: onde vive, o que come?
Muito se fala dessa linguagem hoje em dia, mas você sabe mesmo pra que ela é usada? Hora de descobrir!

Hipsters Ponto Tech #67 - A Linguagem Go

Participantes:

Links:

Produção e conteúdo:

  • Alura Cursos online de Tecnologia
  • Caelum Ensino e Inovação

Edição e sonorização: Radiofobia Podcast e Multimídia.

17 Nov 19:14

New – AWS PrivateLink for AWS Services: Kinesis, Service Catalog, EC2 Systems Manager, Amazon EC2 APIs, and ELB APIs in your VPC

by Ana Visneski

This guest post is by Colm MacCárthaigh, Senior Engineer for Amazon Virtual Private Cloud.


Since VPC Endpoints launched in 2015, creating Endpoints has been a popular way to securely access S3 and DynamoDB from an Amazon Virtual Private Cloud (VPC) without the need for an Internet gateway, a NAT gateway, or firewall proxies. With VPC Endpoints, the routing between the VPC and the AWS service is handled by the AWS network, and IAM policies can be used to control access to service resources.

Today we are announcing AWS PrivateLink, the newest generation of VPC Endpoints which is designed for customers to access AWS services in a highly available and scalable manner, while keeping all the traffic within the AWS network. Kinesis, Service Catalog, Amazon EC2, EC2 Systems Manager (SSM), and Elastic Load Balancing (ELB) APIs are now available to use inside your VPC, with support for more services coming soon such as Key Management Service (KMS) and Amazon Cloudwatch.

With traditional endpoints, it’s very much like connecting a virtual cable between your VPC and the AWS service. Connectivity to the AWS service does not require an Internet or NAT gateway, but the endpoint remains outside of your VPC. With PrivateLink, endpoints are instead created directly inside of your VPC, using Elastic Network Interfaces (ENIs) and IP addresses in your VPC’s subnets. The service is now in your VPC, enabling connectivity to AWS services via private IP addresses. That means that VPC Security Groups can be used to manage access to the endpoints and that PrivateLink endpoints can also be accessed from your premises via AWS Direct Connect.

Using the services powered by PrivateLink, customers can now manage fleets of instances, create and manage catalogs of IT services as well as store and process data, without requiring the traffic to traverse the Internet.

Creating a PrivateLink Endpoint
To create a PrivateLink endpoint, I navigate to the VPC Console, select Endpoints, and choose Create Endpoint.

I then choose which service I’d like to access. New PrivateLink endpoints have an “interface” type. In this case I’d like to use the Kinesis service directly from my VPC and I choose the kinesis-streams service.

At this point I can choose which of my VPCs I’d like to launch my new endpoint in, and select the subnets that the ENIs and IP addresses will be placed in. I can also associate the endpoint with a new or existing Security Group, allowing me to control which of my instances can access the Endpoint.

Because PrivateLink endpoints will use IP addresses from my VPC, I have the option to over-ride DNS for the AWS service DNS name by using VPC Private DNS. By leaving Enable Private DNS Name checked, lookups from within my VPC for “kinesis.us-east-1.amazonaws.com” will resolve to the IP addresses for the endpoint that I’m creating. This makes the transition to the endpoint seamless without requiring any changes to my applications. If I’d prefer to test or configure the endpoint before handling traffic by default, I can leave this disabled and then change it at any time by editing the endpoint.

Once I’m ready and happy with the VPC, subnets and DNS settings, I click Create Endpoint to complete the process.

Using a PrivateLink Endpoint

By default, with the Private DNS Name enabled, using a PrivateLink endpoint is as straight-forward as using the SDK, AWS CLI or other software that accesses the service API from within your VPC. There’s no need to change any code or configurations.

To support testing and advanced configurations, every endpoint also gets a set of DNS names that are unique and dedicated to your endpoint. There’s a primary name for the endpoint and zonal names.

The primary name is particularly useful for accessing your endpoint via Direct Connect, without having to use any DNS over-rides on-premises. Naturally, the primary name can also be used inside of your VPC.
The primary name, and the main service name – since I chose to over-ride it – include zonal fault-tolerance and will balance traffic between the Availability Zones. If I had an architecture that uses zonal isolation techniques, either for fault containment and compartmentalization, low latency, or for minimizing regional data transfer I could also use the zonal names to explicitly control whether my traffic flows between or stays within zones.

Pricing & Availability
AWS PrivateLink is available today in all AWS commercial regions except China (Beijing). For the region availability of individual services, please check our documentation.

Pricing starts at $0.01 / hour plus a data processing charge at $0.01 / GB. Data transferred between availability zones, or between your Endpoint and your premises via Direct Connect will also incur the usual EC2 Regional and Direct Connect data transfer charges. For more information, see VPC Pricing.

Colm MacCárthaigh

 

17 Nov 19:12

Novidades do Spring Framework 5

by Alexandre Afonso

O Spring Framework 5 foi lançado, depois de mais ou menos 4 anos trabalhando com a versão 4 do framework. Então, vem comigo, para você não ficar pra trás.

Claro que não dá para acompanharmos tudo o que evolui no mercado, mas você, como um programador Spring, precisa ter uma boa noção de como está o andamento desse framework. E é justamente isso que você e eu estamos fazendo agora: nos atualizando.

Agora, relaxa aí, que esse é um daqueles artigos rapidinhos de ler, e nem vai te deixar com a consciência pesada por não executar o código de exemplo, simplesmente, porque não tem.

Vamos lá?

O que tem de novo no Spring Framework 5?

As duas maiores novidades, sem dúvida, são a nova baseline com Java 8 e o suporte a programação reativa (Spring WebFlux). Além desses dois pontos, ainda podemos destacar:

  • Revisão no núcleo do framework
  • Pacotes, classes e métodos descontinuados
  • Spring Web MVC
  • Melhorias para os testes unitários

Aprofundando um pouquinho mais, veremos alguns detalhes dessas novidades da versão 5.

Nova linha de base com JDK 8+ e Java EE 7+

Agora, o mínimo que você precisa para usar o Spring Framework 5 é o Java 8. Toda a linha de base agora está em cima dessa versão do Java. E é fácil imaginar os benefícios, não é mesmo? Isso deixou o código mais legível, principalmente, pelo uso de generics, lambdas, etc.

E para quem esperou tanto pelo Java 9, o framework também é compatível com essa versão. Chegou até a se cogitar em ter Java 9 como linha de base, mas isso acabou sendo deixado de lado para que essa dependência não impedisse a entrega do Spring 5.

Em nível de API, ele é compatível com Java EE 8 e atende aos requisitos do Servlet 4.0, Bean Validation 2.0 e a nova JSON Binding API. Dentre outros, já foi testado com Tomcat 9.0 e Hibernate Validator 6.0, sendo que o Java EE 7 é o mínimo requerido.

Programação reativa (Spring WebFlux)

Uma novidade bem forte do framework é a programação reativa, através do framework Spring WebFlux. Ele é uma alternativa ao Spring MVC, que segue os princípios da reatividade e é totalmente assíncrono e não-bloqueante. Nesse modelo de programação, é possível escalar a aplicação verticalmente com um número menor de threads.

A boa notícia é que o Spring WebFlux é bem parecido com o já existente Spring MVC, ou seja, você vai aproveitar o que já conhece de programação web com esse framework, caso queira entrar no mundo reativo. Inclusive, eles podem até ser usados na mesma aplicação.

Claro que isso não é o fim do Spring MVC. Nem toda aplicação precisa desse tipo de solução, que é mais complexa, por isso o Spring MVC ainda vai continuar sendo usado.

Revisão no núcleo do framework

O código-fonte do Spring Framework 5 não é só totalmente compatível com Java 8, como também foi revisado para poder se beneficiar do uso de todas as funcionalidades do mesmo.

Aqui entra, por exemplo:

  • O uso de lambdas
  • Da API de reflexão mais recente
  • O uso de default methods nas interfaces
  • Uso das anotações @Nullable e @NotNull, para marcar parâmetros e retornos que permitem ou não valores nulos. Assim, vai ser possível evitar alguns “NullPointerException” em tempo de compilação
  • Ao invés do Commons Logging, o Spring 5 vem com seu próprio integrador de logs, que irá auto-detectar o Log4j 2.x, SLF4J, JUL (java.util.logging), sem nenhum intermediário

Pacotes, classes e métodos descontinuados

Nessa nova versão, tivemos também alguns pontos do framework que foram descontinuados. Dentre esses pontos, temos alguns pacotes, que são:

  • beans.factory.access
  • jdbc.support.nativejdbc
  • mock.staticmock do módulo spring-aspects
  • web.view.tiles2 – Agora, é necessário o Tiles na versão 3
  • orm.hibernate3 e orm.hibernate4 – A versão suportada agora é o Hibernate 5

Ainda tivemos a remoção de suporte das seguintes bibliotecas:

  • Portlet
  • Velocity
  • JasperReports
  • XMLBeans
  • JDO
  • Guava

Caso você precise do suporte para essas bibliotecas e/ou pacotes, é recomendado que você se mantenha na versão 4.3.x do framework.

Spring Web MVC

A prova de que o Spring Web MVC ainda está bem vivo, são as novidades que tivemos para ele nessa nova versão.

Primeiro, que ele está integrado com o WebFlux, e foi atualizado para utilizar a nova JSON Binding API do Java EE 8 e ainda as versões do Jackson 2.9 e Protobuf 3.

Saiu também o suporte para PushBuilder do Servlet 4.0, como argumento de métodos de um controlador do Spring MVC.

Ainda temos o suporte para retornar Reactor 3.1 FluxMono, e RxJava 1.3 e 2.1 a partir de métodos dos controladores, visando o uso do novo WebClient reativo ou em repositórios reativos do Spring Data.

Melhorias para os testes unitários

Nesse ponto foi implementado o suporte completo para JUnit 5. Temos também o suporte para execução de testes paralelos com Spring TestContext Framework.

Para testes em sistemas reativos, o Spring trouxe o WebTestClient, que de maneira parecida ao MockMvc, não precisa de um servidor rodando.

Conclusão

Tivemos várias coisas legais nessa nova versão do Spring Framework, mas, sem dúvida, as maiores são a entrada do framework no mundo reativo e a linha de base com o Java 8.

O legal também é que essas mudanças vão disparar várias outras nos outros frameworks do ecossistema Spring, como o Spring Security, Spring Data, Spring Integration, etc, sem contar que é sempre empolgante ver que o framework que usamos está a todo vapor.

Se você deseja baixar o Spring manualmente, então pode entrar no site spring.io. Mas…

Para quem deseja entrar nesse mundo da alta produtividade no desenvolvimento com Spring, aconselho que faça agora o download do nosso e-book Produtividade no Desenvolvimento de Aplicações Web com Spring Boot.

Ebook Spring Boot

Espero que tenha gostado de conhecer as novidades do Spring Framework 5. :)

No mais, um abraço pra você e até uma próxima!

The post Novidades do Spring Framework 5 first appeared on Blog da AlgaWorks.

13 Nov 19:37

Primeira ‘nação espacial’ humana é oficialmente colocada em órbita

by Douglas Ciriaco
Apesar de ser um território proclamado como “Reino Espacial de Asgardia”, o satélite tem aproximadamente o tamanho de uma caixa de leite

A NASA colocou em órbita no último domingo (12) a primeira ‘nação espacial’. Trata-se de Asgardia, um “reino espacial” composto por um único satélite que tem aproximadamente o tamanho de uma caixa de leite longa vida. O Asgardia-1 partiu do Wallops Flight Facility, localizada em Virgínia, nos Estados Unidos, e marca o primeiro território soberano enviado da Terra para o espaço.

Apesar do tamanho diminuto, o novo país soberano que agora flutua pelo espaço já conta com mais de 300 mil “cidadãos” que se inscreveram online para fazer parte do Reino Espacial de Asgardia. E qual a vantagem disso? Ao se tornar um cidadão desta nação soberana, é possível enviar armazenar dados ali, mantendo tudo a quilômetros de distância da Terra (mas, obviamente, todo o conteúdo ainda está sujeito às leis daqui, mais especificamente às leis cibernéticas austríacas).

Leia mais...

11 Nov 20:15

Esse Japones Faz Quadros Realistas Usando Apenas Lápis

Esse Japones Faz Quadros Realistas Usando Apenas Lápis

Meu amigo...é muito treino de disciplina, sem palavras!

09 Nov 13:28

5 dicas para melhorar a acessibilidade em sua interface

by Natan Souza

Será que acessibilidade é algo tão complicado que vale a pena eu abrir mão de 25% dos meus usuários? Acessibilidade normalmente é um tema que não é muito abordado por aí, seja por falta de informação ou de interesse. Confira cinco dicas para melhorar a acessibilidade do seu projeto.

Tanto no curso de UX, quanto nos cursos de Front-end da Caelum sempre levantamos pontos conceituais e técnicos deste tema tão importante. Muitos alunos vão para o curso de UX querendo melhorar a usabilidade do site de sua empresa, mas usabilidade está totalmente amarrada à acessibilidade:

E por favor, não me venha com essa de “não é meu público-alvo” ou “não temos tempo”. Saiba que além de ser lei, cerca de 1/4 da população brasileira tem algum tipo de deficiência. Olá querido amigo-leitor com miopia!

Fala com a minha mão

Não é meu público-alvo blá blá blá….

Agora vamos te ajudar a deixar sua interface mais acessível com algumas dicas/macetes.

1 – Não depender da cor para passar informação

Você é o mais novo desenvolvedor em uma empresa de gestão horizontal. Aí chega na hora de ver a prioridade de cada tarefa no Trello pelas etiquetas e você se depara com isso:

Etiquetas do Trello simulando daltonismo

 

Entre elas temos categorias como “feito”, “melhorias” e “bug que pode custar seu emprego”. Qual você atacaria primeiro? A vermelha claro… Percebeu como é perigoso depender da cor para passar alguma informação?

O que poderia ser feito é colocar uma legenda ou mesmo uma textura para diferenciar as etiquetas entre si, tarefa que o pessoal do Trello fez com louvor:

Trello labels with texture

Pra fazer um teste de como ficaria aos olhos de um daltônico, normalmente vou no Photoshop e em “View > Proof Setup > Color Blindness”. Mas existem várias extensões para o Chrome que ajudam nisso também.

Outro exemplo disso é quando dá erro em algum formulário e só a borda do campo fica vermelha para indicar o erro. Você pode ajudar o usuário com um apoio visual (um ícone) ou um apoio textual:

Input with and without error message

2 – Não tirarás o zoom do usuário

Eu uso óculos. Além de deixar o iOS com textos em negrito e aumentar a fonte do sistema como um todo, eu constantemente preciso dar zoom em sites. Aí por algum motivo divino alguém achou que era uma boa ideia travar o zoom para eu não enxergar o conteúdo do site. Afinal, tem que ficar bonitinho

Zoom dont allowed

Toda vez que você bloqueia o zoom no seu site ou app, um filhote de panda escorrega e cai no cimento. Apesar de ser fácil travar o zoom, ferir essa liberdade só se justificaria se a experiência de usuário fosse bastante prejudicada por conta disso. Entretanto, recomendo que tenha mais empatia e repense essa UX.

3 – Imagens de conteúdo precisam do atributo ALT

Você entra no seu e-commerce preferido para ver se tem promoção de roupa e aparece isso logo na home:

Promotion 20% off banner example

Bacana! 20% de desconto é um baita desconto! Agora olha como fica para o leitor de tela de uma pessoa cega:

Example banner without alt attribute

Não tão bacana agora, ele vai ler apenas “Imagem…”, como que o software vai saber do que se trata a imagem?! Como que o usuário cego vai saber que está rolando uma promoção? Hoje, infelizmente, os softwares leitores de tela ainda não conseguem ler o conteúdo de uma imagem sem um apoio textual, o atributo alt.  Veja como não é nada complicado colocar o alt em uma imagem no HTML:

<img src="imagens/destaque-home.png" alt="Promoção: Sunny Days 20% off">

Alguns pontos interessantes sobre o alt:

  • você colocou o texto “imagem de um robô” no alt de uma imagem, o leitor de tela lerá “Imagem: imagem de um robô”. Redundante? Com certeza! Evite;
  • se não há nada para ser colocado em algum alt, repense a função da imagem, se ela for decorativa coloque-a via CSS com técnicas de image replacement. Se não puder tirar, deixe o alt vazio;
  • além de melhorar a acessibilidade, você melhorará a experiência de uso para conexões mais lentas e também sua posição no Google;
  • o Facebook tem uma AI monstruosa que está gerando alt automático. Dê um “Inspect element” em algumas fotos suas ou olha esse print aqui. Ainda um pouco aberto demais, mas estamos evoluindo bem;
  • Recomendo fortemente investir meia hora do seu tempo e ver esta talk do Reinaldo Ferraz sobre o alt.

 

4 – HTML semântico com sabedoria

Essa pode levar meses para você dominar, mas preocupe-se em quando estiver marcando o conteúdo do seu site em marcá-lo corretamente.

Se um texto tem função de subtítulo, por que marcá-lo com um <p> se existe um elemento específico para isso, no caso, o <h2>? Isso é ruim tanto para acessibilidade quanto para SEO.

Além disso, há alguns leitores de tela que possuem atalhos para escaneamento rápido dos títulos da página, que tal ajudar nisso?

Outros pontos rápidos?

  • se for pra navegação, use o <a>, se for interação ou em formulários use o <button>;
  • campos de texto sempre atrelados a algum rótulo (<label>) sobre o que é aquele campo;
  • se precisa de um container e não sabe direito qual elemento do HTML5 usar, melhor ser genérico com <div> do que marcar erroneamente;
  • quer passar a ideia que um texto é importante, use o elemento <strong>, o <b> seria visual, e visual é CSS;
  • use o atributo lang correspondente ao idioma da página, e até de trechos que sejam diferentes do da página;
  • o leitor de tela não diferencia atualmente <h1> de <main> e <h1> de <footer>, mantenha a regra antiga limitando-se a um por página;
  • placeholder não substitui <label> e isso é regra.

 

5 – Menu muito grande? Link para pular para o conteúdo

Você resolveu ir a um show e acabou quebrando os braços (não me pergunte como) enquanto pulava loucamente ao som de Night Train. Ortopedista disse que em duas semanas você poderá tirar o gesso, e enquanto isso só conseguirá usar o computador com um dedo… Vai ter que se virar usando só a tecla TAB.

Aí você entra em algum e-commerce e tem que passar por quinhentos itens no menu de navegação até chegar no produto que você quer. Nada legal… Solução? Um link escondido para pular para o conteúdo principal! Algo como o WordPress faz:

Jump to main content in WordPress

Como que esse atalho surge? No primeiro TAB que o usuário der! Simples e facilita bastante a vida de quem depende do teclado para navegação, como no exemplo que dei acima (deficiência temporária) ou algum tipo de deficiência permanente ou situacional.

E claro, dê uma tratada com carinho na ordem dos tabs com a ajuda do atributo tabindex.

 

Implementei tudo isso já, e agora?

Legal, Natan. Implementei essa lista e várias outras coisas mas como saber se está ok?“.

Quando você troca uma lâmpada como você sabe se funcionou? Você testa!
Várias coisas bacanas que você pode fazer para testar:

  • desligar o monitor e tentar navegar usando um leitor de tela como o NVDA;
  • tentar navegar apenas via teclado;
  • tirar o óculos para ver se os tamanho das fontes estão decentes;
  • usar alguma extensão como o Spectrum que simula a visão daltônica;
  • lista com validadores automáticos de acessibilidade;
  • contratar deficientes visuais para fazer testes de usabilidade.

A melhor maneira de verificar se o seu site é acessível é testando!

 

Quem seguir e onde pegar mais informações

 

Já viu o curso de Acessibilidade web na Alura? Mostra que acessibilidade começa bem antes de colocar a mão no código!

E como a acessibilidade é tratada, ou não tratada, na sua empresa hoje?
Quais os desafios e desculpas que aparecem no dia-a-dia?

Conta aí nos comentários!

 

The post 5 dicas para melhorar a acessibilidade em sua interface appeared first on Blog da Caelum: desenvolvimento, web, mobile, UX e Scrum.

09 Nov 13:27

Now Available – Compute-Intensive C5 Instances for Amazon EC2

by Jeff Barr

I’m thrilled to announce that the new compute-intensive C5 instances are available today in six sizes for launch in three AWS regions!

These instances are designed for compute-heavy applications like batch processing, distributed analytics, high-performance computing (HPC), ad serving, highly scalable multiplayer gaming, and video encoding. The new instances offer a 25% price/performance improvement over the C4 instances, with over 50% for some workloads. They also have additional memory per vCPU, and (for code that can make use of the new AVX-512 instructions), twice the performance for vector and floating point workloads.

Over the years we have been working non-stop to provide our customers with the best possible networking, storage, and compute performance, with a long-term focus on offloading many types of work to dedicated hardware designed and built by AWS. The C5 instance type incorporates the latest generation of our hardware offloads, and also takes another big step forward with the addition of a new hypervisor that runs hand-in-glove with our hardware. The new hypervisor allows us to give you access to all of the processing power provided by the host hardware, while also making performance even more consistent and further raising the bar on security. We’ll be sharing many technical details about it at AWS re:Invent.

The New Instances
The C5 instances are available in six sizes:

Instance Name vCPUs
RAM
EBS Bandwidth Network Bandwidth
c5.large 2 4 GiB Up to 2.25 Gbps Up to 10 Gbps
c5.xlarge 4 8 GiB Up to 2.25 Gbps Up to 10 Gbps
c5.2xlarge 8 16 GiB Up to 2.25 Gbps Up to 10 Gbps
c5.4xlarge 16 32 GiB 2.25 Gbps Up to 10 Gbps
c5.9xlarge 36 72 GiB 4.5 Gbps 10 Gbps
c5.18xlarge 72 144 GiB 9 Gbps 25 Gbps

Each vCPU is a hardware hyperthread on a 3.0 GHz Intel Xeon Platinum 8000-series processor. This custom processor, optimized for EC2, allows you have full control over the C-states on the two largest sizes, allowing you to run a single core at up to 3.5 GHz using Intel Turbo Boost Technology.

As you can see from the table, the four smallest instance sizes offer substantially more EBS and network bandwidth than the previous generation of compute-intensive instances.

Because all networking and storage functionality is implemented in hardware, C5 instances require HVM AMIs that include drivers for the Elastic Network Adapter (ENA) and NVMe. The latest Amazon Linux, Microsoft Windows (Windows Server 2012 R2 and Windows Server 2016), Ubuntu, RHEL, CentOS, SLES, Debian, and FreeBSD AMIs all support C5 instances. If you are doing machine learning inferencing, or other compute-intensive work, be sure to check out the most recent version of the Intel Math Kernel Library. It has been optimized for the Intel® Xeon® Platinum processor and has the potential to greatly accelerate your work.

In order to remain compatible with instances that use the Xen hypervisor, the device names for EBS volumes will continue to use the existing /dev/sd and /dev/xvd prefixes. The device name that you provide when you attach a volume to an instance is not used because the NVMe driver assigns its own device name (read Amazon EBS and NVMe to learn more):

The nvme command displays additional information about each volume (install it using sudo yum -y install nvme-cli if necessary):

The SN field in the output can be mapped to an EBS volume ID by inserting a “-” after the “vol” prefix (sadly, the NVMe SN field is not long enough to store the entire ID). Here’s a simple script that uses this information to create an EBS snapshot of each attached volume:

$ sudo nvme list | \
  awk '/dev/ {print(gensub("vol", "vol-", 1, $2))}' | \
  xargs -n 1 aws ec2 create-snapshot --volume-id

With a little more work (and a lot of testing), you could create a script that expands EBS volumes that are getting full.

Getting to C5
As I mentioned earlier, our effort to offload work to hardware accelerators has been underway for quite some time. Here’s a recap:

CC1 – Launched in 2010, the CC1 was designed to support scale-out HPC applications. It was the first EC2 instance to support 10 Gbps networking and one of the first to support HVM virtualization. The network fabric that we designed for the CC1 (based on our own switch hardware) has become the standard for all AWS data centers.

C3 – Launched in 2013, the C3 introduced Enhanced Networking and uses dedicated hardware accelerators to support the software defined network inside of each Virtual Private Cloud (VPC). Hardware virtualization removes the I/O stack from the hypervisor in favor of direct access by the guest OS, resulting in higher performance and reduced variability.

C4 – Launched in 2015, the C4 instances are EBS Optimized by default via a dedicated network connection, and also offload EBS processing (including CPU-intensive crypto operations for encrypted EBS volumes) to a hardware accelerator.

C5 – Launched today, the hypervisor that powers the C5 instances allow practically all of the resources of the host CPU to be devoted to customer instances. The ENA networking and the NVMe interface to EBS are both powered by hardware accelerators. The instances do not require (or support) the Xen paravirtual networking or block device drivers, both of which have been removed in order to increase efficiency.

Going forward, we’ll use this hypervisor to power other instance types and plan to share additional technical details in a set of AWS re:Invent sessions.

Launch a C5 Today
You can launch C5 instances today in the US East (Northern Virginia), US West (Oregon), and EU (Ireland) Regions in On-Demand and Spot form (Reserved Instances are also available), with additional Regions in the works.

One quick note before I go: The current NVMe driver is not optimized for high-performance sequential workloads and we don’t recommend the use of C5 instances in conjunction with sc1 or st1 volumes. We are aware of this issue and have been working to optimize the driver for this important use case.

Jeff;

09 Nov 13:26

New Amazon S3 Encryption & Security Features

by Jeff Barr

Back in 2006, when I announced S3, I wrote ” Further, each block is protected by an ACL (Access Control List) allowing the developer to keep the data private, share it for reading, or share it for reading and writing, as desired.”

Starting from that initial model, with private buckets and ACLs to grant access, we have added support for bucket policies, server access logging, versioning, API logging, cross-region replication, and multiple client-side and server-side encryption options, all with the goal of giving you the tools you need to keep your data safe while allowing you to share it with customers and partners as needed. We also brought the power of Artificial Intelligence and machine learning in to play, with the launch of Amazon Macie, a tool that helps you to discover, classify, and secure content at scale.

Today we are adding five new encryption and security features to S3:

Default Encryption – You can now mandate that all objects in a bucket must be stored in encrypted form without having to construct a bucket policy that rejects objects that are not encrypted.

Permission Checks – The S3 Console now displays a prominent indicator next to each S3 bucket that is publicly accessible.

Cross-Region Replication ACL Overwrite – When you replicate objects across AWS accounts, you can now specify that the object gets a new ACL that gives full access to the destination account.

Cross-Region Replication with KMS – You can now replicate objects that are encrypted with keys that are managed by AWS Key Management Service (KMS).

Detailed Inventory Report – The S3 Inventory report now includes the encryption status of each object. The report itself can also be encrypted.

Let’s take a look at each one…

Default Encryption
You have three server-side encryption options for your S3 objects: SSE-S3 with keys that are managed by S3, SSE-KMS with keys that are managed by AWS KMS, and SSE-C with keys that you manage. Some of our customers, particularly those who need to meet compliance requirements that dictate the use of encryption at rest, have used bucket policies to ensure that every newly stored object is encrypted. While this helps them to meet their requirements, simply rejecting the storage of unencrypted objects is an imperfect solution.

You can now mandate that all objects in a bucket must be stored in encrypted form by installing a bucket encryption configuration. If an unencrypted object is presented to S3 and the configuration indicates that encryption must be used, the object will be encrypted using encryption option specified for the bucket (the PUT request can also specify a different option).

Here’s how to enable this feature using the S3 Console when you create a new bucket. Enter the name of the bucket as usual and click on Next. Then scroll down and click on Default encryption:

Select the desired option and click on Save (if you select AWS-KMS you also get to designate a KMS key):

You can also make this change via a call to the PUT Bucket Encryption function. It must specify an SSE algorithm (either SSE-S3 or SSE-KMS) and can optionally reference a KMS key.

Keep the following in mind when you implement this feature:

SigV4 – Access to the bucket policy via the S3 REST API must be signed with SigV4 and made over an SSL connection.

Updating Bucket Policies – You should examine and then carefully modify existing bucket policies that currently reject unencrypted objects.

High-Volume Use – If you are using SSE-KMS and are uploading many hundreds or thousands of objects per second, you may bump in to the KMS Limit on the Encrypt and Decrypt operations. Simply file a Support Case and ask for a higher limit:

Cross-Region Replication – Unencrypted objects will be encrypted according to the configuration of the destination bucket. Encrypted objects will remain as such.

Permission Checks
The combination of bucket policies, bucket ACLs, and Object ACLs give you very fine-grained control over access to your buckets and the objects within them. With the goal of making sure that your policies and ACLs combine to create the desired effect, we recently launched a set of Managed Config Rules to Secure Your S3 Buckets. As I mentioned in the post, these rules make use of some of our work to put Automated Formal Reasoning to use.

We are now using the same underlying technology to help you see the impact of changes to your bucket policies and ACLs as soon as you make them. You will know right away if you open up a bucket for public access, allowing you to make changes with confidence.

Here’s what it looks like on the main page of the S3 Console (I’ve sorted by the Access column for convenience):

The Public indicator is also displayed when you look inside a single bucket:

You can also see which Permission elements (ACL, Bucket Policy, or both) are enabling the public access:

Cross-Region Replication ACL Overwrite
Our customers often use S3’s Cross-Region Replication to copy their mission-critical objects and data to a destination bucket in a separate AWS account. In addition to copying the object, the replication process copies the object ACL and any tags associated with the object.

We’re making this feature even more useful by allowing you to enable replacement of the ACL as it is in transit so that it grants full access to the owner of the destination bucket. With this change, ownership of the source and the destination data is split across AWS accounts, allowing you to maintain separate and distinct stacks of ownership for the original objects and their replicas.

To enable this feature when you are setting up replication, choose a destination bucket in a different account and Region by specifying the Account ID and Bucket name, and clicking on Save:

Then click on Change object ownership…:

We’ve also made it easier for you to set up the key policy for the destination bucket in the destination account. Simply log in to the account and find the bucket, then click on Management and Replication, then choose Receive objects… from the More menu:

Enter the source Account ID, enable versioning, inspect the policies, apply them, and click on Done:

Cross-Region Replication with KMS
Replicating objects that have been encrypted using SSE-KMS across regions poses an interesting challenge that we are addressing today. Because the KMS keys are specific to a particular region, simply replicating the encrypted object would not work.

You can now choose the destination key when you set up cross-region replication. During the replication process, encrypted objects are replicated to the destination over an SSL connection. At the destination, the data key is encrypted with the KMS master key you specified in the replication configuration. The object remains in its original, encrypted form throughout; only the envelope containing the keys is actually changed.

Here’s how you enable this feature when you set up a replication rule:

As I mentioned earlier, you may need to request an increase in your KMS limits before you start to make heavy use of this feature.

Detailed Inventory Report
Last but not least, you can now request that the daily or weekly S3 inventory reports include information on the encryption status of each object:

As you can see, you can also request SSE-S3 or SSE-KMS encryption for the report.

Now Available
All of these features are available now and you can start using them today! There is no charge for the features, but you will be charged the usual rates for calls to KMS, S3 storage, S3 requests, and inter-region data transfer.

Jeff;

 

08 Nov 23:56

Microsoft SQL Server 2017 para Linux

by Cassio Augusto

Dia 25 de Setembro, a Microsoft anunciou a chegada do SQL Server para o Linux. Está é a primeira vez que o servidor chega para o sistema operacional em uma versão completa e com suporte oficial.

Além disso, a gigante também está disponibilizando o SQL Server 2017 no Red Hat Enterprise Linux com desconto até junho do ano que vem.

O lançamento acompanha a evolução do SQL server que deixou de ser um simples sistema de administração de banco de dados e se tornou um software que também é usado na análise de dados, aprendizado de máquina e ciência de dados. Um dos componentes principais da nova versão é o suporte para executar cargas de trabalho de aprendizado de máquina dentro do SQL server usando o Python.

Outro fator interessante é que o preço do software não mudou desde o lançamento do SQL Server 2016. Ou seja, o preço é o mesmo para Windows e Linux.

A Microsoft também está trabalhando para que seus clientes movam as cargas de trabalho do SQL Server dos centros de dados físicos locais para a nuvem Azure com mais facilidade. O processo está sendo feito através do Database Migration, projeto que foi criado para fornecer um caminho semi-automatizado para a nuvem com um tempo de inatividade nulo. Dessa maneira os clientes podem manter seus aplicativos mais importantes em funcionamento enquanto fazem a migração.

https://docs.microsoft.com/pt-br/sql/linux/sql-server-linux-setup

https://docs.microsoft.com/pt-br/sql/linux/sql-server-linux-setup

https://docs.microsoft.com/pt-br/sql/linux/sql-server-linux-setup

 

O post Microsoft SQL Server 2017 para Linux apareceu primeiro em Ninja do Linux.

06 Nov 20:13

Quais são as linguagens que os programadores mais "odeiam"?

by noreply@blogger.com (Cláudio Florenzano)
Quais são as linguagens que os programadores mais "odeiam"?
Quais são as linguagens que os programadores mais "odeiam"?
O Stack Overflow, conhecido site de perguntas e respostas para programadores, tem uma seção em que você pode cadastrar seu currículo e informar quais linguagens você prefere usar no trabalho, e quais pretende evitar. Esta informação fica pública em seu perfil.

Após analisar centenas de milhares de perfis, o Stack Overflow descobriu as linguagens de programação mais “odiadas” pela comunidade.

O Perl está na frente, e por uma margem bem grande. Ela foi criada por Larry Wall, linguista e programador da NASA, no final dos anos 80. Trata-se de uma linguagem bastante versátil, mas que pode ser confusa e deselegante, criando dores de cabeça para o programador. Por isso, em comparação a um canivete suíço, ela é descrita como uma “motosserra suíça”.

Na sequência, temos Delphi e VBA (usada nas macros do Excel), seguidas de longe pelo PHP, Objective-C, CoffeeScript e Ruby. No outro extremo, os programadores demonstram maior interesse em R, Kotlin e TypeScript.

É bom deixar claro: a análise do Stack Overflow não significa que os programadores tenham ódio pessoal contra o Perl ou Delphi. Na verdade, isso mostra que eles preferem não trabalhar com essas linguagens — talvez porque não sejam muito desejáveis para suas carreiras.

Temos também o outro lado: há quem odeie JavaScript, mas não há como fazer desenvolvimento web sem ele, então você não vai encontrar essa linguagem como a mais “odiada”. Para a análise, foram consideradas as linguagens com pelo menos 2 mil menções nos Developer Stories.

O Stack Overflow também fez uma análise mais abrangente, levando em conta sistemas operacionais, plataformas e bibliotecas que os desenvolvedores preferem evitar. As tecnologias mais “odiadas” são o Internet Explorer, Visual Basic, COBOL e Adobe Flash.

Faz todo o sentido que desenvolvedores não queiram trabalhar, por exemplo, com o Internet Explorer: a própria Microsoft migrou seu foco para o Edge, ainda que o navegador para Windows 10 tenha suas limitações. Por sua vez, o Flash já tem data para morrer.

Como explica o Stack Overflow, “isso não é uma acusação contra as tecnologias, sua qualidade ou sua popularidade. É simplesmente uma medida de quais tecnologias estimulam sentimentos negativos fortes em pelo menos um subconjunto de desenvolvedores, que se sentem confortáveis ​​compartilhando isso publicamente”.

Fonte: Tecnoblog
02 Nov 20:00

Scheduled Workflows

This feature enables Workflows to run on a configurable schedule. Refer to the Scheduling a Workflow section of the Orchestrating Workflows document for instructions and examples. Reference information for syntax is available in the triggers section of the Writing Jobs With Steps document and answers to common questions are documented in the Workflows section of the Migration FAQ.

27 Oct 20:30

REST: Princípios e boas práticas

by Rodrigo Ferreira

Representational State Transfer, abreviado como REST, não é uma tecnologia, uma biblioteca, e nem tampouco uma arquitetura, mas sim um modelo a ser utilizado para se projetar arquiteturas de software distribuído, baseadas em comunicação via rede.

REST é um dos modelos de arquitetura que foi descrito por Roy Fielding, um dos principais criadores do protocolo HTTP, em sua tese de doutorado e que foi adotado como o modelo a ser utilizado na evolução da arquitetura do protocolo HTTP.

Muitos desenvolvedores perceberam que também poderiam utilizar o modelo REST para a implementação de Web Services, com o objetivo de se integrar aplicações pela Web, e passaram a utilizá-lo como uma alternativa ao SOAP.

REST na verdade pode ser considerado como um conjunto de princípios, que quando aplicados de maneira correta em uma aplicação, a beneficia com a arquitetura e padrões da própria Web.

Vejamos agora esses princípios e como utilizá-los de maneira correta.

Identificação dos Recursos

Toda aplicação gerencia algumas informações. Uma aplicação de um E-commerce, por exemplo, gerencia seus produtos, clientes, vendas, etc. Essas coisas que uma aplicação gerencia são chamadas de Recursos no modelo REST.

Um recurso nada mais é do que uma abstração sobre um determinado tipo de informação que uma aplicação gerencia, sendo que um dos princípios do REST diz que todo recurso deve possuir uma identificação única. Essa identificação serve para que a aplicação consiga diferenciar qual dos recursos deve ser manipulado em uma determinada solicitação.

Imagine a seguinte situação: Você desenvolveu um Web Service REST que gerencia seis tipos de recursos. Os clientes desse Web Service manipulam esses recursos via requisições HTTP. Ao chegar uma requisição para o Web Service, como ele saberá qual dos recursos deve ser manipulado? É justamente por isso que os recursos devem possuir uma identificação única, que deve ser informada nas requisições.

A identificação do recurso deve ser feita utilizando-se o conceito de URI (Uniform Resource Identifier), que é um dos padrões utilizados pela Web. Alguns exemplos de URI’s:

  • http://servicorest.com.br/produtos;
  • http://servicorest.com.br/clientes;
  • http://servicorest.com.br/clientes/57;
  • http://servicorest.com.br/vendas.

As URI’s são a interface de utilização dos seus serviços e funcionam como um contrato que será utilizado pelos clientes para acessá-los. Vejamos agora algumas boas práticas no uso de URI’s.

Utilize URI’s legíveis

Ao definir uma URI, utilize nomes legíveis por humanos, que sejam de fácil dedução e que estejam relacionados com o domínio da aplicação. Isso facilita a vida dos clientes que utilizarão o serviço, além de reduzir a necessidade de documentações extensas.

Utilize o mesmo padrão de URI na identificação dos recursos

Mantenha a consistência na definição das URI’s. Crie um padrão de nomenclatura para as URI’s dos recursos e utilize sempre esse mesmo padrão. Evite situações como:

  • http://servicorest.com.br/produto (Singular);
  • http://servicorest.com.br/clientes (Plural);
  • http://servicorest.com.br/processosAdministrativos (Camel Case);
  • http://servicorest.com.br/processos_judidicais (Snake Case).

Evite adicionar na URI a operação a ser realizada no recurso

Os recursos que uma aplicação gerencia podem ser manipulados de diversas maneiras, sendo para isso disponibilizada algumas operações para manipula-los, tais como: criar, listar, excluir, atualizar, etc.

A manipulação dos recursos deve ser feita utilizando-se os métodos do protocolo HTTP, que inclusive é um dos princípios do REST que será discutido mais adiante.

Portanto, evite definir URI’s que contenham a operação a ser realizada em um recurso, tais como:

  • http://servicorest.com.br/produtos/cadastrar;
  • http://servicorest.com.br/clientes/10/excluir;
  • http://servicorest.com.br/vendas/34/atualizar.

Evite adicionar na URI o formato desejado da representação do recurso

É comum que um serviço REST suporte múltiplos formatos para representar seus recursos, tais como XML, JSON e HTML. A informação sobre qual o formato desejado por um cliente ao consultar um serviço REST deve ser feita via Content Negotiation, conforme será mostrado mais adiante.

Portanto, evite definir URI’s que contenham o formato desejado de um recurso, tais como:

  • http://servicorest.com.br/produtos/xml;
  • http://servicorest.com.br/clientes/112?formato=json.

Evite alterações nas URI’s

A URI é a porta de entrada de um serviço. Se você a altera, isso certamente causará impacto nos clientes que estavam a utilizando, pois você alterou a forma de acesso a ele. Após definir uma URI e disponibilizar a manipulação de um recurso por ela, evite ao máximo sua alteração.

Nos casos mais críticos, no qual realmente uma URI precisará ser alterada, notifique os clientes desse serviço previamente. Verifique também a possibilidade de se manter a URI antiga, fazendo um redirecionamento para a nova URI.

Utilização dos métodos HTTP para manipulação dos recursos

Os recursos gerenciados por uma aplicação, e identificados unicamente por meio de sua URI, geralmente podem ser manipulados de diversas maneiras. É possível criá-los, atualizá-los, excluí-los, dentre outras operações.

Quando um cliente dispara uma requisição HTTP para um serviço, além da URI que identifica quais recursos ele pretende manipular, é necessário que ele também informe o tipo de manipulação que deseja realizar no recurso. É justamente aí que entra um outro conceito da Web, que são os métodos do protocolo HTTP.

O protocolo HTTP possui diversos métodos, sendo que cada um possui uma semântica distinta, e devem ser utilizados para indicar o tipo de manipulação a ser realizada em um determinado recurso.

Vejamos agora os principais métodos do protocolo HTTP e o cenário de utilização de cada um deles:

GET Obter os dados de um recurso.
POST Criar um novo recurso.
PUT Substituir os dados de um determinado recurso.
PATCH Atualizar parcialmente um determinado recurso.
DELETE Excluir um determinado recurso.
HEAD Similar ao GET, mas utilizado apenas para se obter os cabeçalhos de resposta, sem os dados em si.
OPTIONS Obter quais manipulações podem ser realizadas em um determinado recurso.

Geralmente as aplicações apenas utilizam os métodos GET, POST, PUT e DELETE, mas se fizer sentido em sua aplicação utilizar algum dos outros métodos, não há nenhum problema nisso.

Veja a seguir o padrão de utilização dos métodos HTTP em um serviço REST, que é utilizado pela maioria das aplicações e pode ser considerado uma boa prática. Como exemplo será utilizado um recurso chamado Cliente.

Método URI Utilização
GET /clientes Recuperar os dados de todos os clientes.
GET /clientes/id Recuperar os dados de um determinado cliente.
POST /clientes Criar um novo cliente.
PUT /clientes/id Atualizar os dados de um determinado cliente.
DELETE /clientes/id Excluir um determinado cliente.

Como boa prática, em relação aos métodos do protocolo HTTP, evite utilizar apenas o método POST nas requisições que alteram o estado no servidor, tais como: cadastro, alteração e exclusão, e principalmente, evite utilizar o método GET nesses tipos de operações, pois é comum os navegadores fazerem cache de requisições GET, as disparando antes mesmo do usuário clicar em botões e links em uma pagina HTML.

Representações dos recursos

Os recursos ficam armazenados pela aplicação que os gerencia. Quando são solicitados pelas aplicações clientes, por exemplo em uma requisição do tipo GET, eles não “abandonam” o servidor, como se tivessem sido transferidos para os clientes. Na verdade, o que é transferido para a aplicação cliente é apenas uma representação do recurso.

Um recurso pode ser representado de diversas maneiras, utilizando-se formatos específicos, tais como XML, JSON, HTML, CSV, dentre outros. Exemplo de representação de um recurso no formato XML.

<cliente>
	<nome>Rodrigo</nome>
	<email>rodrigo@email.com.br</email>
	<sexo>Masculino</sexo>
	<endereco>
		<cidade>Brasilia</cidade>
		<uf>DF</uf>
	</endereco>
</cliente>

A comunicação entre as aplicações é feita via transferência de representações dos recursos a serem manipulados. Uma representação pode ser também considerada como a indicação do estado atual de determinado recurso.

Essa comunicação feita via transferência de representações dos recursos gera um desacoplamento entre o cliente e o servidor, algo que facilita bastante a manutenção das aplicações.

Suporte diferentes representações

É considerada uma boa prática o suporte a múltiplas representações em um serviço REST, pois isso facilita a inclusão de novos clientes. Ao suportar apenas um tipo de formato, um serviço REST limita seus clientes, que deverão se adaptar para conseguir se comunicar com ele.

Os três principais formatos suportados pela maioria dos serviços REST são:

  • HTML;
  • XML;
  • JSON.

Utilize Content Negotiation para o suporte de múltiplas representações

Quando um serviço REST suporta mais de um formato para as representações de seus recursos, é comum que ele espere que o cliente forneça a informação de qual o formato desejado. No REST, essa negociação do formato da representação dos recursos é chamada de Content Negotiation e no mundo Web ela deve ser feita via um cabeçalho HTTP, conhecido como accept.

Ao fazer uma chamada ao serviço REST, um cliente pode adicionar na requisição o cabeçalho accept, para indicar ao servidor o formato desejado da representação do recurso. Claro, deve ser um formato que seja suportado pelo serviço REST.

Comunicação Stateless

A Web é o principal sistema que utiliza o modelo REST. Hoje ela suporta bilhões de clientes conectados e trocando informações. Mas, como é possível a Web ter uma escalabilidade e performance tão boas, a ponto de conseguir suportar tamanho número de clientes sem problemas?

A resposta: Comunicação Stateless!

Requisições feitas por um cliente a um serviço REST devem conter todas as informações necessárias para que o servidor as interprete e as execute corretamente. Clientes não devem depender de dados previamente armazenados no servidor para processar uma requisição. Qualquer informação de estado deve ser mantida pelo cliente e não pelo servidor. Isso reduz a necessidade de grandes quantidades de recursos físicos, como memória e disco, e também melhora a escalabilidade de um serviço REST.

É justamente por essa característica que a Web consegue ter uma escalabilidade praticamente infinita, pois ela não precisa manter as informações de estado de cada um dos clientes.

Esse é um dos princípios mais difíceis de ser aplicado em um serviço REST, pois é muito comum que aplicações mantenham estado entre requisições de clientes. Um exemplo dessa situação acontece quando precisamos armazenar os dados dos usuários que estão autenticados na aplicação.

Evite manter dados de autenticação/autorização em sessão

A principal dificuldade em criar um serviço REST totalmente Stateless ocorre quando precisamos lidar com os dados de autenticação/autorização dos clientes. A dificuldade ocorre porque é natural para os desenvolvedores armazenarem tais informações em sessão, pois essa é a solução comum ao se desenvolver uma aplicação Web tradicional.

A principal solução utilizada para resolver esse problema é a utilização de Tokens de acesso, que são gerados pelo serviço REST e devem ser armazenados pelos clientes, via cookies ou HTML 5 Web Storage, devendo também ser enviados pelos clientes a cada nova requisição ao serviço.

Já existem diversas tecnologias e padrões para se trabalhar com Tokens, dentre elas:

  • OAUTH;
  • JWT (JSON Web Token);
  • Keycloack.

Inclusive tal assunto já foi tratado aqui no blog.

HATEOAS (Hypermedia As The Engine Of Application State)

Para entendermos melhor o conceito de HATEOAS, vamos a um exemplo comum quando utilizamos a Web.

Imagine que você quer comprar um produto pela Web, em algum site de E-commerce. Você entra no site, navega pelas categorias de produtos via menu do site, encontra o seu produto e chega até a tela de detalhes dele, que possui as informações de preço, frete e o botão para realizar a compra.

Mas nem sempre o produto está disponível em estoque, por isso o site costuma fazer um tratamento nessa situação, escondendo o botão de realizar a compra e exibindo um botão para notificação quando o produto voltar a estar disponível.

No exemplo anterior, o conceito de HATEOAS foi aplicado duas vezes. Primeiro, quando o cliente entrou no site de E-commerce, como ele fez para chegar até a página de detalhes do produto? Navegando via links.

Normalmente todo site ou aplicação Web possui diversas funcionalidades, sendo que a navegação entre elas costuma ser feita via links. Um cliente até pode saber a URI de determinada página ou recurso, mas se ele não souber precisamos guiá-lo de alguma maneira para que ele encontre as informações que procura.

O segundo uso do HATEOAS ocorreu quando o cliente acessou a página de detalhes do produto. Se o produto estivesse em estoque, o site apresentaria o botão de comprar, e o cliente poderia finalizar seu pedido. Caso contrário, ele apenas poderia registrar-se para ser notificado. Tudo isso é feito, principalmente, para garantir a consistência das informações.

Perceba que os links foram utilizados como mecanismo para conduzir o cliente quanto à navegação e ao estado dos recursos. Esse é o conceito que foi chamado de HATEOAS, que nada mais é do que a utilização de Hypermedia, com o uso de links, como o motor para guiar os clientes quanto ao estado atual dos recursos, e também quanto as transições de estado que são possíveis no momento.

Veja um exemplo de uma representação de um recurso sem a utilização do conceito de HATEOAS:

<pedido>
	<id>1459</id>
	<data>2017-01-20</data>
	<status>PENDENTE</status>
	<cliente>
		<nome>Rodrigo</nome>
	</cliente>
</pedido>

No exemplo anterior foi apresentado a representação do recurso “Pedido” no formato XML, contendo suas informações, mas sem o uso do HATEOAS. Isso certamente pode gerar algumas dúvidas para os clientes desse serviço REST, como por exemplo:

  • É possível solicitar o cancelamento do pedido? Como?
  • Quais são os outros estados do pedido e como transitar entre eles?
  • Como obter mais informações sobre o cliente desse pedido?

Essas dúvidas poderiam ser respondidas facilmente se o conceito HATEOAS fosse utilizado, facilitando assim a vida dos clientes do serviço REST. Vejamos agora a mesma representação, porém com a utilização do HATEOAS:

<pedido self="http://servicorest.com.br/pedidos/1459">
	<id>1459</id>
	<data>2017-01-20</data>
	<status>PENDENTE</status>
	<cliente ref="http://servicorest.com.br/clientes/784" />
	<acoes>
		<acao>
			<rel>self</rel>
			<uri>http://servicorest.com.br/pedidos/1459</uri>
			<method>GET</method>
		</acao>
		<acao>
			<rel>cancelar</rel>
			<uri>http://servicorest.com.br/pedidos/1459</uri>
			<method>DELETE</method>
		</acao>
	</acoes>
</pedido>

Perceba como agora ficou muito mais simples explorar as informações e descobrir quais caminhos seguir. HATEOAS é um dos princípios que dificilmente vemos sendo aplicados em serviços REST no mercado, quase sempre por falta de conhecimento dos desenvolvedores.

Utilização correta dos códigos HTTP

Na verdade, esse não é um princípio do REST, mas sim uma boa prática.

No protocolo HTTP, toda requisição feita por um cliente a um servidor deve resultar em uma resposta, sendo que nela existe um código HTTP, utilizado para informar o resultado da requisição, tenha ela sido processada com sucesso ou não.

Existem dezenas de códigos HTTP, cada um tendo sua semântica especifica e devendo ser utilizado quando fizer sentido. Os códigos HTTP são agrupados em classes, conforme demonstrado a seguir:

Classe Semântica
2xx Indica que a requisição foi processada com sucesso.
3xx Indica ao cliente uma ação a ser tomada para que a requisição possa ser concluída.
4xx Indica erro(s) na requisição causado(s) pelo cliente.
5xx Indica que a requisição não foi concluída devido a erro(s) ocorrido(s) no servidor.

A boa prática consiste em conhecer os principais códigos HTTP e utilizá-los de maneira correta. Veja os principais códigos HTTP e quando os utilizar:

Código Descrição Quando utilizar
200 OK Em requisições GET, PUT e DELETE executadas com sucesso.
201 Created Em requisições POST, quando um novo recurso é criado com sucesso.
206 Partial Content Em requisições GET que devolvem apenas uma parte do conteúdo de um recurso.
302 Found Em requisições feitas à URI’s antigas, que foram alteradas.
400 Bad Request Em requisições cujas informações enviadas pelo cliente sejam invalidas.
401 Unauthorized Em requisições que exigem autenticação, mas seus dados não foram fornecidos.
403 Forbidden Em requisições que o cliente não tem permissão de acesso ao recurso solicitado.
404 Not Found Em requisições cuja URI de um determinado recurso seja inválida.
405 Method Not Allowed Em requisições cujo método HTTP indicado pelo cliente não seja suportado.
406 Not Acceptable Em requisições cujo formato da representação do recurso requisitado pelo cliente não seja suportado.
415 Unsupported Media Type Em requisições cujo formato da representação do recurso enviado pelo cliente não seja suportado.
429 Too Many Requests No caso do serviço ter um limite de requisições que pode ser feita por um cliente, e ele já tiver sido atingido.
500 Internal Server Error Em requisições onde um erro tenha ocorrido no servidor.
503 Service Unavailable Em requisições feitas a um serviço que esta fora do ar, para manutenção ou sobrecarga.

Utilize o código correto para cada tipo de situação. Evite a má prática de sempre utilizar um mesmo código genérico para todas as situações, como por exemplo o código 200 para qualquer tipo de requisição bem-sucedida ou o código 500 para qualquer requisição malsucedida.

Conclusão

REST não é um bicho de sete cabeças. Possui apenas alguns poucos princípios e restrições que devem ser utilizados para se garantir algumas características importantes em aplicações e serviços, tais como: portabilidade, escalabilidade e desacoplamento.

A Web é o principal exemplo de implementação do modelo REST, e deveríamos nos espelhar nela ao construir nossos serviços seguindo esse mesmo modelo.

Todos os conceitos do modelo REST descritos nesse post podem também ser utilizados na implementação de aplicações Web, e não somente nos casos de integração de sistemas via Web Services.

Inclusive se você utilizar esses conceitos em uma aplicação Web tradicional, e um dia ela precisar se tornar uma API REST, o impacto das mudanças será mínimo, pois sua aplicação já estará seguindo os princípios REST. O que mudará é que agora ao invés de devolver para os clientes apenas páginas HTML ela também pode devolver as informações dos recursos em algum formato, como o JSON, e o cliente é quem vai se preocupar em como formatá-los.

Quando uma aplicação ou serviço segue os princípios descritos nesse artigo, ela é chamada de RESTful. Alguns puristas consideram apenas como RESTful a aplicação ou serviço que seguir todos os princípios do REST, inclusive os menos utilizados, como comunicação Stateless e HATEOAS.

Mas, não foque em ser ou não considerado RESTful, e sim em tentar utilizar o máximo possível dos princípios REST, para que sua aplicação ou serviço obtenha todos os benefícios desse modelo.

 

E você leitor, utiliza de maneira correta os princípios REST? Conte-nos sua experiência 🙂

The post REST: Princípios e boas práticas appeared first on Blog da Caelum: desenvolvimento, web, mobile, UX e Scrum.

12 Oct 14:34

Spring Vault GA 1.0 é lançado

by Andrew Morgan

A Pivotal anunciou a versão final do Spring Vault 1.0. O Spring Vault é uma biblioteca java que oferece abstrações para serem utilizadas por aplicações cliente em torno do Hashicorp Vault, uma ferramenta para gerenciamento de credenciais.Por seguir o idioma do Spring, o Hashicorp Vault pode ser integrado facilmente com aplicações Spring ou Java.

By Andrew Morgan Translated by Alefh Sousa
10 Oct 01:26

ASP.NET Core 2 possibilita utilização de Razor Pages

by Jeff Martin

ASP.NET Core 2 chegou com uma gama de novas funcionalidades, incluindo o Razor Pages, novos modelos de desenvolvimento e uma série de mudanças para facilitar o desenvolvimento. Combinando padrões simplificados até a ter configurações mais detalhadas para quem busca uma melhor personalização, ASP.NET Core 2 pretende fazer parte de projetos de todos os tamanhos.

By Jeff Martin Translated by Danilo Pereira de Luca
10 Oct 01:23

Git para corajosos – Rebase – Parte 01

by Filipe Mondaini

Este é o primeiro de uma série de artigos sobre coisas legais e perigosas que podemos fazer com Git.

Rebase versus Merge

O Rebase é um comando que tem uma reputação ruim. Com bastante frequência, ouço de outras pessoas que uma das primeiras lições que tiveram ao aprender Git, é que o Rebase é um comando proibido por ser muito perigoso. Mas o que muita gente não sabe é que o Rebase, quando dominado, pode ajudar muito a vida do desenvolvedor ou do DevOps.

Merge

Uma das coisas mais importantes sobre o Rebase, é que ele resolve o mesmo problema do Merge: ambos integram mudanças de um branch para outro, só que de maneira diferente.

Imagine que você comece trabalhando em uma nova feature de um branch e então outro membro do time atualiza o branch master. O que temos como resultado é um fork do histórico que é bem familiar para qualquer um que já usou o Git:

Agora, digamos que os novos commits no branch master são importantes para a feature na qual você está trabalhando. Para adicionar os novos commits no branch feature, você tem duas opções: Merge ou Rebase.

Fazendo o Merge

É a opção mais fácil. Podemos fazer o Merge do master em nosso branch com o comando:

git checkout feature
git merge master

O resultado é a criação de um commit do próprio Merge, unindo os históricos dos dois branches. Então temos agora uma estrutura parecida com esta:

O merge é interessante porque é uma operação não destrutiva. Os commits dos branches existentes não são alterados e isso evita alguns riscos do Rebase.

Por outro lado, também significa que o branch feature terá um um commit irrelevante todas as vezes que você precisar incorporar mudanças. Se o branch principal tem muita atividade, isso vai poluir bastante o branch no qual está trabalhando e isso gera impacto direto aos outros desenvolvedores, que não vão conseguir entender o histórico do projeto.

Rebase

Então, como alternativa ao Merge, você pode fazer o Rebase do branch feature no branch master, utilizando os comandos:

git checkout feature
git rebase master

Basicamente, o que o rebase faz é reproduzir, commit por commit, as ações que você desejar. No nosso caso, reproduzindo os novos commits de master no branch feature.

E se você não se sente confortável com o Git Rebase, você pode treinar o Rebase em um branch temporário. Assim, se você fizer besteira, você pode tentar de novo fazendo um checkout do branch original:

git checkout feature
git checkout -b temporary-branch
git rebase -i master
# [Clean up the history]
git checkout master
git merge temporary-branch

Depois do Rebase, o nosso histórico fica assim:

A Regra Áurea do Rebase

Agora que já entendemos basicamente o que é o rebase, precisamos falar da Regra Áurea:

“Nunca faça um rebase enquanto você está trabalhando em um branch público”.

O problema é que isso precisa ser combinado com as outras pessoas envolvidas no repositório. Lembre-se, com o rebase nós estamos reescrevendo a história, então é como uma conspiração: todos precisam estar dentro do esquema para tudo dar certo. E quanto mais pessoas envolvidas, mais difícil fica.

Por enquanto é isso, pessoal! Na parte 2 desta série vou falar um pouco mais de outras coisas que podemos fazer com o Git Rebase, usando o modo interativo.

Algumas referências, caso queira estudar mais:

Até a próxima!

***

Este artigo foi publicado originalmente em: https://www.concrete.com.br/2017/09/04/git-para-corajosos-rebase-parte-1/

06 Oct 15:32

Cronjobs com Docker

by Cristiano Diedrich

Oi Pessoal,

Hoje vamos trazer para vocês um forma de resolver algo que é bem recorrente e comum em ambientes de produção, e que talvez acabe de tornando uma porta de entrada para o uso do Docker em maior escala. Dessa vez, você entenderá como é possível realizar o agendamento e execução de script utilizando a crontab dentro de containers Docker \o/.

Para quem ainda não sabe, dentro de ambiente like *unix é possível realizar o agendamento de scripts utilizando uma ferramenta chamada Crontab (para quem é do ambiente Microsoft, é o mesmo que o task scheduler, mas com mais poder 🙂 ), através dela você define o horário de execução para os scripts, usuário que será utilizado para a execução do mesmo, e claro, qual script deve ser executado. Pois bem, sabendo disso, é possível utilizar o Docker para que a execução desses scripts seja realizada dentro de containers.

Mas afinal, quais as vantagens disso?

Bem, a execução de script via crontab, pode gerar alguns desafios, principalmente se não há um controle rigoroso de quais scripts estão sendo agendados, dentre os desafios podemos destacar:

1 – Uso excessivo de recursos: Pode acontecer de algum script ter algum erro e fazer com que haja uso excessivo de recursos (memória, cpu) durante a sua execução, e acredite, isso é mais comum do que imagina. Existe formas de contornar isso, no entanto, nativamente não.

2 – Segurança na execução: Você pode definir qual usuário executará um determinado script, isso funciona muito bem dentro da crontab, no entanto, caso você não especifique, o usuário utilizado para a execução do script  será o mesmo que inicializou o serviço da cron, e geralmente este serviço inicializa com o usuário root, então…

Ok Cristiano, e como o Docker pode me ajudar?

Aeooooo mais um convertido, vamos ver como funciona na prática?

A primeira coisa que faremos é criar os diretório necessários, para isso, defina um diretório de trabalho, e nele crie uma pasta chamada “cron” e outra chamada “scripts”. Em seguida vamos buildar uma imagem Docker apenas com o que precisamos para realizar a execução dos scripts, como imagem base, vamos utilizar uma do NodeJS Alpine, lembrando que, neste caso nossa cron executará um script escrito em node, você deve adaptar a imagem de acordo com a sua necessidade (se seu script é em PHP, então a imagem deve ser PHP, e assim por diante) veja como ficou nosso Dockerfile:

FROM node:8-alpine
RUN apk update && apk add tzdata &&\ 
    cp /usr/share/zoneinfo/America/Sao_Paulo /etc/localtime &&\ 
    echo "America/Sao_Paulo" > /etc/timezone &&\ 
    apk del tzdata && rm -rf /var/cache/apk/*
CMD chown root:root /etc/crontabs/root && /usr/sbin/crond -f

Não preciso explicar este Dockerfile né, você já deve ter lido este post né? 😉 salve-o dentro da pasta “cron”.

Bem, agora precisamos montar o resto do ambiente, para este lab, vamos criar um arquivo chamado cron1 com o seguinte conteúdo:

0 7,19 * * * /usr/local/bin/node /home/mundodocker/hello.js >> /var/log/cronteste/hello.log 2>&1

Neste caso, o script será executado as 7h e as 19h todos os dias, salve-o dentro da pasta “cron” também.

Veja, que neste caso o script que deverá ser executado é o /home/mundodocker/hello.js que contém algo simples em node:

console.log("Hello world");

Salve-o dentro da pasta “scripts”.

Ok, agora estamos quase prontos, pelo menos, tudo que precisamos está pronto, se quisermos podemos utilizar essa estrutura, pois ai já contém tudo que é necessário, obvio que isso não basta, visto que a intenção é deixar tudo automatizado. Para isso, é necessário que você tenha o docker-compose instalado, com isso conseguimos automatizar 100% do ambiente. Como você já sabe, para utilizarmos o docker-compose, precisamos de um arquivo no formato yaml com as definições de nosso ambiente, veja como ficou nosso docker-compose.yml:

version: "3"
services:
    cron:
        build: cron
        container_name: cronteste
        volumes:
            - /var/log/cronteste:/var/log/cronteste
            - ./cron/cron1:/etc/crontabs/root
            - ./sripts:/home/mundodocker

Para validar, você pode executar o comando:

docker-compose up

Com isso ele fará o build da imagem e em seguida iniciará um container com esse agendamento. Além das opções acima, você pode por exemplo limitar os recursos desse container, inclusive definir um valor minimo para o mesmo. Outra possibilidade é iniciar este container com um usuário especifico, dessa forma você não terá problemas com aquela execução com usuário root 😉

Validou? Tudo certo? Agora vamos fazer com que esse mesmo comando seja executado na inicialização do servidor, visto que, ele ficará no somente enquanto o servidor estiver ligado, e obviamente os agendamentos serão perdidos, não queremos isso certo?

Pois bem, em sistema onde você tem o systemd (Ubuntu, RedHat, Fedora, CentOS) você deverá criar um novo service, para isso, crie dentro de: “/lib/systemd/system/” um arquivo com nome de: docker-cron.service com o seguinte conteúdo:

[Unit]
Description=Docker Cron
Requires=docker.service
After=docker.service

[Service]
Restart=always
ExecStart=/usr/local/bin/docker-compose -f /home/mundodocker/docker-compose.yml up
ExecStop=/usr/local/bin/docker-compose -f /home/mundodocker/docker-compose.yml stop

[Install]
WantedBy=default.target

Criado o arquivo, basta fazer com que o systemctl releia o arquivo e adicione o serviço a sua base:

systemctl daemon-reload

Agora é simples, vamos adicionar este serviço ao startup do servidor:

systemctl enable docker-infra

Dessa forma você pode administrar da mesma forma que um serviço, ou seja, posso iniciar e parar esse agendamento a qualquer momento, e mesmo que o servidor seja reiniciado, o agendamento será persistido.

 

Ok, agora sim temos tudo 100% automático, não precisamos nos preocupar com mais nada, a não ser é claro em estender isso a  outros tipos de agendamento (se for este o seu caso é claro). Bom, por hora era isso, ficou com dúvida? Tem algo a contribuir? Por favor deixe nos comentários e vamos melhorando juntos 😉

 

Obrigado e grande abraço!

03 Oct 00:56

Using Enhanced Request Authorizers in Amazon API Gateway

by Stefano Buliani

Recently, AWS introduced a new type of authorizer in Amazon API Gateway, enhanced request authorizers. Previously, custom authorizers received only the bearer token included in the request and the ARN of the API Gateway method being called. Enhanced request authorizers receive all of the headers, query string, and path parameters as well as the request context. This enables you to make more sophisticated authorization decisions based on parameters such as the client IP address, user agent, or a query string parameter alongside the client bearer token.

Enhanced request authorizer configuration

From the API Gateway console, you can declare a new enhanced request authorizer by selecting the Request option as the AWS Lambda event payload:

Create enhanced request authorizer

 

Just like normal custom authorizers, API Gateway can cache the policy returned by your Lambda function. With enhanced request authorizers, however, you can also specify the values that form the unique key of a policy in the cache. For example, if your authorization decision is based on both the bearer token and the IP address of the client, both values should be part of the unique key in the policy cache. The identity source parameter lets you specify these values as mapping expressions:

  • The bearer token appears in the Authorization header
  • The client IP address is stored in the sourceIp parameter of the request context.

Configure identity sources

 

Using enhanced request authorizers with Swagger

You can also define enhanced request authorizers in your Swagger (Open API) definitions. In the following example, you can see that all of the options configured in the API Gateway console are available as custom extensions in the API definition. For example, the identitySource field is a comma-separated list of mapping expressions.

securityDefinitions:
  IpAuthorizer:
    type: "apiKey"
    name: "IpAuthorizer"
    in: "header"
    x-amazon-apigateway-authtype: "custom"
    x-amazon-apigateway-authorizer:
      authorizerResultTtlInSeconds: 300
      identitySource: "method.request.header.Authorization, context.identity.sourceIp"
      authorizerUri: "arn:aws:apigateway:us-east-1:lambda:path/2015-03-31/functions/arn:aws:lambda:us-east-1:XXXXXXXXXX:function:py-ip-authorizer/invocations"
      type: "request"

After you have declared your authorizer in the security definitions section, you can use it in your API methods:

---
swagger: "2.0"
info:
  title: "request-authorizer-demo"
basePath: "/dev"
paths:
  /hello:
    get:
      security:
      - IpAuthorizer: []
...

Enhanced request authorizer Lambda functions

Enhanced request authorizer Lambda functions receive an event object that is similar to proxy integrations. It contains all of the information about a request, excluding the body.

{
    "methodArn": "arn:aws:execute-api:us-east-1:XXXXXXXXXX:xxxxxx/dev/GET/hello",
    "resource": "/hello",
    "requestContext": {
        "resourceId": "xxxx",
        "apiId": "xxxxxxxxx",
        "resourcePath": "/hello",
        "httpMethod": "GET",
        "requestId": "9e04ff18-98a6-11e7-9311-ef19ba18fc8a",
        "path": "/dev/hello",
        "accountId": "XXXXXXXXXXX",
        "identity": {
            "apiKey": "",
            "sourceIp": "58.240.196.186"
        },
        "stage": "dev"
    },
    "queryStringParameters": {},
    "httpMethod": "GET",
    "pathParameters": {},
    "headers": {
        "cache-control": "no-cache",
        "x-amzn-ssl-client-hello": "AQACJAMDAAAAAAAAAAAAAAAAAAAAAAAAAAAA…",
        "Accept-Encoding": "gzip, deflate",
        "X-Forwarded-For": "54.240.196.186, 54.182.214.90",
        "Accept": "*/*",
        "User-Agent": "PostmanRuntime/6.2.5",
        "Authorization": "hello"
    },
    "stageVariables": {},
    "path": "/hello",
    "type": "REQUEST"
}

The following enhanced request authorizer snippet is written in Python and compares the source IP address against a list of valid IP addresses. The comments in the code explain what happens in each step.

...
VALID_IPS = ["58.240.195.186", "201.246.162.38"]

def lambda_handler(event, context):

    # Read the client’s bearer token.
    jwtToken = event["headers"]["Authorization"]
    
    # Read the source IP address for the request form 
    # for the API Gateway context object.
    clientIp = event["requestContext"]["identity"]["sourceIp"]
    
    # Verify that the client IP address is allowed.
    # If it’s not valid, raise an exception to make sure
    # that API Gateway returns a 401 status code.
    if clientIp not in VALID_IPS:
        raise Exception('Unauthorized')
    
    # Only allow hello users in!
    if not validate_jwt(userId):
        raise Exception('Unauthorized')

    # Use the values from the event object to populate the 
    # required parameters in the policy object.
    policy = AuthPolicy(userId, event["requestContext"]["accountId"])
    policy.restApiId = event["requestContext"]["apiId"]
    policy.region = event["methodArn"].split(":")[3]
    policy.stage = event["requestContext"]["stage"]
    
    # Use the scopes from the bearer token to make a 
    # decision on which methods to allow in the API.
    policy.allowMethod(HttpVerb.GET, '/hello')

    # Finally, build the policy.
    authResponse = policy.build()

    return authResponse
...

Conclusion

API Gateway customers build complex APIs, and authorization decisions often go beyond the simple properties in a JWT token. For example, users may be allowed to call the “list cars” endpoint but only with a specific subset of filter parameters. With enhanced request authorizers, you have access to all request parameters. You can centralize all of your application’s access control decisions in a Lambda function, making it easier to manage your application security.

03 Oct 00:49

Improved Testing on the AWS Lambda Console

by Orr Weinstein

(This post has been written by Chris Tate, SDE on the Lambda Console team)

Today, AWS Lambda released three console enhancements:

  • A quicker creation flow that lets you quickly create a function with the minimum working configuration, so that you can start iterating faster.
  • A streamlined configuration page with Lambda function settings logically grouped into cards, which makes locating and making changes much easier.
  • Persisting multiple events to help test your function.

This post focuses on persisting test events, and I discuss how I’ve been using this new feature. Now when you are testing on the Lambda console, you can save up to 10 test events per function, and each event can be up to 6 megabytes in size, the maximum payload size for synchronous invocations. The events are saved for the logged-in user, so that two different users in the same account have their own set of events.

Testing Lambda functions

As a Lambda console developer, when I work on side projects at home, I sometimes use our development server. I’ve been using this new feature to test a Lambda function in one of my projects. The function is probably more complicated than it should be, because it can be triggered by an Alexa skill, Amazon CloudWatch schedule, or an Amazon API Gateway API. If you have had a similarly complicated function, you may have run into the same problem I did:  How do you test?

For quick testing, I used the console but the console used to save only one test event at a time. To work around this, my solution was a text file with three different JSON events, one for each trigger. I would copy whatever event I needed into the Lambda console, tweak it, and choose Test. This would become particularly annoying when I wanted to quickly test all three.

I also switch between my laptop and desktop depending on my mood. For that reason, I needed to make sure this text file with the events were shared in some way, as the console only locally saved one test event to the current browser. But now you don’t have to worry about any of that.

Walkthrough

In the Lambda console, go to the detail page of any function, and select Configure test events from the test events dropdown (the dropdown beside the orange test button). In the dialog box, you can manage 10 test events for your function. First, paste your Alexa trigger event in the dialog box and type an event name, such as AlexaTrigger.

Choose Create. After it saves, you see AlexaTrigger in the Test list.

When you open the dialog box again by choosing Configure test events, you are in edit mode.

To add another event, choose Create new test event. Now you can choose from a list of templates or any of your previously saved test events. This is very useful for a couple of reasons:

  • First, when you want to slightly tweak one of your existing events and still keep the earlier version intact.
  • Second, when you are not sure how to structure a particular event from an event source. You can use one of the sample event templates and tweak them to your needs. Skip it when you know what your event should be.

Paste in your CloudWatch schedule event, give it a name, and choose Create. Repeat for API Gateway.

Now that you have three events saved, you can quickly switch between them and repeatedly test. Furthermore, if you’re on your desktop but you created the test events on your laptop, there’s no problem. You can still see all your events and you can switch back and forth seamlessly between different computers.

Conclusion

This feature should allow you to more easily test your Lambda functions through the console. If you have more suggestions, add a comment to this post or submit feedback through the console. We actually read the feedback, believe it!

29 Sep 00:18

Falha em app do Nubank deixava expostas compras de outros usuários

by Rafaela Pozzebom

Atenção usuários do Nubank! Uma falha de segurança no aplicativo da Nubank estava enviando notificações de transferências realizadas por outros usuários para clientes da fintech. Conforme o desenvolvedor Rafael Nilton, em um relato publicado no Medium, ele começou a receber notificações de todas as compras realizadas por outro usuário que tinha logado e deslogado a própria conta no celular de Nilton.

Deste modo, mesmo que o outro usuário havia deslogado do aplicativo da Nubank do seu aparelho, ele continuou recebendo as notificações de transferência. Mesmo que as pessoas envolvidas neste caso eram conhecidas, o fato denota violação de privacidade.

Falha em app do Nubank deixava expostas compras de outros usuáriosFalha em app do Nubank deixava expostas compras de outros usuários

Leia também:

Continue a leitura...

28 Sep 02:20

Orquestradores distribuídos com uma arquitetura de microservices

by Andrew Morgan

Martin Campbell, especialista em escalabilidade de microservices na DigitalOcean,falou sobre como rodar Orquestradores distribuídos em uma arquitetura de microservices na conferência MicroXchg Berlin de 2017. Ele focou nos problemas encontrados durante o processo de migração, e falou sobre as vantagens e desvantagens dos orquestradores como Kubernetes, Nomad e Mesos.

By Andrew Morgan Translated by Alefh Sousa
28 Sep 02:19

O mínimo que você deve saber de Java 9

by Rodrigo Turini

O título não é uma coincidência, esse post foi criado com o mesmo intuito daquele que eu escrevi em 2014 junto com o Paulo Silveira, anunciando as principais alterações da nova versão da linguagem Java. Com pequenas e enormes mudanças, o JDK 9 já está disponível para download.

São muitas as novidades e eu vou compartilhar aqui um resumo das principais delas, além de passar vários links e recursos que você pode utilizar para se atualizar.

Um java interativo

Ao baixar e configurar o Java 9 em seu ambiente você já consegue utilizar uma das grandes introduções da versão, que é a nova ferramenta REPL (Read-Eval-Print Loop).

Ela traz uma forma muito mais interessante de experimentar código, sem toda burocracia e verbosidade das classes com método main. Basta abrir o console, digitar jshell — que é o nome da ferramenta — e sair escrevendo código Java!

turini ~ $ jshell
| Welcome to JShell — Version 9
| For an introduction type: /help intro

Eu li a documentação completa da nova especificação da linguagem com o JShell aberto, experimentando cada uma das mudanças e com zero preocupações de setup. Foi uma experiência incrível.

Nesse outro post eu mostro vários exemplos com os principais detalhes e possibilidades.

E é muito legal também saber que você pode escrever algum snippet de código nele e depois compartilhar, pra que outras pessoas possam facilmente testar sua implementação — ou mesmo modificá-la e te enviar de volta.

Quer um exemplo? Podemos criar um método com o mesmo código usado no post de Java 8, para retornar a média de tamanho de uma lista de palavras.

Vou abrir o JShell e escrever o código em um método chamado averageLenght:

jshell> public double averageLenght(List<String> words) {
…> return words.stream()
…> .mapToInt(String::length).average()
…> .orElse(0);
…> }
	
| created method averageLenght(List<String>)

Agora criar uma lista de palavras:

jshell> List<String> words = List.of(“podemos”, “criar”, “listas”, “assim”);

E experimentar minha implementação:

jshell> averageLenght(words)
	
==> 5.2

Funciona!

Para salvar esse código e compartilhar, vou usar o comando /save.

jshell> /save average-lenght

O arquivo average-lenght foi criado. Experimente agora baixar esse arquivo e depois abrir o seu jshell com ele como a seguir:

turini ~ $ jshell average-lenght

A lista de palavras e o método averageLenght já vão estar aí, disponíveis para você testar.

Imagina que legal no fórum da Alura ou GUJ, por exemplo, você conseguir enviar o pedacinho de código problemático para que o pessoal abra e te ajude encontrar o problema? Você consegue criar classes, métodos e inclusive usar dependências externas — JARs de bibliotecas etc — nesse ambiente interativo, e tudo que a pessoa precisa é ter o Java 9 instalado.

Um Java reativo

O JDK 9 também evoluiu a arquitetura do pacote java.util.concurrent, com a introdução da Flow API que implementa a especificação de Reactive Streams. A API é composta pela classe abstrata Flow e suas interfaces internas, que seguem o padrão de publicador e assinante — publisher/subscriber pattern.

java.util.concurrent.Flow
java.util.concurrent.Flow.Publisher
java.util.concurrent.Flow.Subscriber
java.util.concurrent.Flow.Processor

Apesar do nome extremamente familiar, Reactive Streams não tem relação direta com a API de Streams do Java 8. Essa é uma confusão completamente comum, mas nesse caso o termo Streams remete a fluxo, fluxos reativos. Um passo criado a partir do caminho definido pelo famoso manifesto reativo.

Ele vem pra resolver o famoso problema de processamentos assíncronos em que um componente de origem envia dados sem saber ao certo se isso está em uma quantidade maior do que aquela com a qual o consumidor pode lidar.

Perceba que na imagem o componente de origem está recebendo e processando várias informações, mas muitas delas estão bloqueadas enquanto as outras estão sendo processadas. Os dados chegam em uma velocidade muito maior do que podem ser atendidos. Com a Flow API você consegue resolver esse e outros problemas avançados em execuções assíncronas com back pressure.

O fluxo seria assim:

No lugar de a origem empurrar uma quantidade arbitrária de dados para o destino, é o destino que puxa apenas a quantidade de dados que ele certamente poderá atender. Só então, os dados são enviados e na quantidade certa.

No exemplo a seguir estamos criando um publicador e registrando implicitamente um consumidor que apenas imprime as Strings conforme elas são enviadas:

jshell> SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
	
jshell> publisher.consume(System.out::println);
	
jshell> List.of("esse", "código", "é", "assíncrono").forEach(publisher::submit);
	
esse
código
é
assíncrono

Um Java modular

Depois de mais de 20 anos muitos dos problemas da antiga estrutura monolítica da plataforma Java foram resolvidos com a introdução de um novo sistema de módulos e a modularização do próprio JDK. Neste outro post eu mostro o Jigsaw e o que muda na estrutura de seus projetos, além de mencionar brevemente como ficou a divisão de suas principais APIs.

No Java 9 tudo é modular, mas você não precisa sair migrando os seus projetos para usar essa nova versão. Especialmente por motivos de compatibilidade, projetos que não definem explicitamente o uso do sistema de módulos vão funcionar normalmente — internamente é declarado um unamed module, com acesso a todos os módulos da plataforma de forma parecida ao que acontece nas versões anteriores.

Apesar disso, depois de conhecer um pouco mais sobre os benefícios dessa migração eu arriscaria dizer que você vai querer migrar. Uma das grandes vantagens dessa nova estrutura é que, diferente da abordagem atual do classpath, as informações do módulo precisam ficar disponíveis da mesma forma durante as fases de compilação e execução. Isso garante uma integridade muito maior nos projetos, evitando problemas da abordagem atual do legado classpath — como o famoso JAR hell —  ou, pelo menos, reportando-os muito antes, em tempo de compilação.

Outro ganho enorme é no encapsulamento dos projetos, já que agora ser público não significa mais ser acessível. Em um sistema modular você precisa definir explicitamente o que pode ou não ser acessado por fora do módulo, e isso guia a construção de APIs com designs mais lógicos.

No exemplo a seguir o arquivo module-info.java, responsável pela definição de um módulo, exemplifica um caso em que o módulo br.com.caelum.desktop precisa do módulo base do Java FX para funcionar, e deixar acessível apenas seu pacote de componentes:

module br.com.caelum.desktop {
	requires javafx.base;
	exports br.com.caelum.desktop.components;
}	

Ah, e em projetos modulares você consegue criar imagens de execução customizadas com apenas o pedacinho da JRE que você está usando! Podemos falar que essa é uma extensão aos compact profiles do JDK 8, mas que funcionam de forma muito mais interessante já que você literalmente só carrega o que precisa. Muitos projetos pequenos podem ter só o java.base, no lugar de todos os 94 módulos e suas milhares de classes. Isso tem uma série de vantagens de performance e consumo de memória, já que a aplicação fica com um footprint inicial muito menor.

Novas APIs

A versão também recebeu diversas novas APIs. Um destaque especial vai para a de HTTP/2 Client, que possui uma interface publica completamente repaginada ante ao legado HttpURLConnection API e com suporte para requisições HTTP/2 e WebSockets.

Um exemplo de código para retornar o conteúdo do corpo de um request seria:

String contentBody = newHttpClient().send(
 newBuilder()
 .uri(new URI(“https://turini.github.io/livro-java-9/"))
 .GET()
 .build(), asString())
 .body();

O mais interessante dessa API é que ela é o piloto de um novo conceito da linguagem, que são os módulos em incubação. A ideia é permitir que APIs passem por um período de testes antes de entrar definitivamente para a linguagem, com objetivo de reduzir a possibilidade de introdução de erros na plataforma, que tem o forte peso da retrocompatibilidade.

Módulos em incubação ainda não fazem parte do Java SE. Eles ficam em um pacote jdk.incubator e não são resolvidos por padrão na compilação ou execução de suas aplicações. Para testar esse meu exemplo no jshell, por exemplo, você precisa iniciar a ferramenta com essa opção explicitamente:

turini ~ $ jshell --add-modules jdk.incubator.httpclient
| Welcome to JShell — Version 9
| For an introduction type: /help intro

O JDK 9 também traz uma nova API de logging, que te possibilita criar um provedor padrão de mensagens que poderá ser usado tanto em seu código como no do próprio JDK. E uma API de Stack-Walking, que tira proveito dos poderosos recursos da API de Streams para que você consiga passear pela Stack de sua aplicação de forma extremamente eficiente. Com ela podemos facilmente coletar em uma lista todas as classes de um pacote específico, ou alguma outra condição especial de filtro:

StackWalker.getInstance().walk(stream -> 
  stream.filter(frame -> frame.getClassName().contains("br.com.caelum")
))
.collect(toList());

Eu consigo ver um futuro próximo em que as IDEs e ferramentas de profilling tiram bastante proveito dessa API para fornecer alternativas performáticas e poderosas para analise e investigação de problemas de runtime.

Diversas mudanças nas APIs

Eu mostrei nesse post que as Collections receberam diversos factory methods trazendo uma forma mais próxima aos collection literals para criação de listas, sets e mapas.

Map.of(1,"Turini", 2,"Paulo", 3,"Guilherme");
	
List.of(1, 2, 3);
	
Set.of("SP", "BSB", "RJ");

O Stream também recebeu novos métodos como dropWhile, takeWhile, ofNullable e uma sobrecarga do iterate que permite definir uma condição para que a iteração termine. Repare a semelhança com o clássico for com index no exemplo em que imprime números de 1 a 10:

Stream
	.iterate(1, n -> n<=10, n -> n+1)
	.forEach(System.out::println);

Além das mudanças no Stream em si, diversas outras APIs receberam métodos que tiram proveito de seus recursos. Um exemplo seria o Optional, que agora consegue projetar seus valores diretamente para o Stream:

Stream<Integer> stream = Optional.of(ids).stream();

Essa transformação é extremamente útil quando você precisa aplicar diversas operações nos valores e tirar proveito da característica lazy da API.

O java.time também recebeu uma forma bastante interessante de retornar streams com intervalo de datas:

Stream<LocalDate> dates = 
	LocalDate.datesUntil(jdk10Release);

E o Scanner agora possui métodos como o findAll onde, dada uma expressão regular, retorna um stream de possíveis resultados.

String input = "esperei 3 anos pelo lançamento do java 9";

List<String> matches = new Scanner(input)
    .findAll("\\d+")
    .map(MatchResult::group)
    .collect(toList());

Extensão aos recursos da linguagem

Além de novos métodos e APIs, a linguagem recebeu um suporte maior na inferência de tipos e nos recursos existentes. O try-with-resources agora pode usar variáveis efetivamente finais, sem precisar re-instanciar como em sua versão agora antiga.

O código que era assim:

public void read(BufferedReader reader) {

  try (BufferedReader reader = reader) {
    //...
  } 
}

Agora pode ser escrito sem a necessidade de criar um novo tipo e da re-atribuição:

public void read(BufferedReader reader) {

  try (reader) {
    //...
  } 
}

O uso do operador diamante em classes anônimas e suporte aos métodos privados em interfaces — para reutilizar código dos default methods sem quebrar encapsulamento — são algumas das várias outras possibilidades. Muitas delas estão definidas na proposta Milling Project Coin, que recebeu esse nome por ser um aperfeiçoamento dos recursos introduzidos no Project Coin do JDK 7 — como o próprio operador diamante.

Performance

As melhorias relacionadas a performance também são incríveis. Um destaque especial foi a adoção do G1 como Garbage Collector padrão, como já era esperado. Ele é um algoritmo bem mais previsível, que executa seu trabalho em diferentes threads e em uma frequência muito maior, compactando o heap de memória durante a execução. O G1 também faz o reaproveitamento de Strings e tem diversos outros benefícios interessantes.

Por falar em Strings, elas agora possuem seu valor representado de uma forma muito mais eficiente em memória. Se você conferir na implementação das versões anteriores da linguagem, perceberá que uma String guarda seu valor interno em um array de caracteres, que mantém dois bytes para cada um deles.

private final char value[];

O problema da abordagem atual é que, na maior parte dos casos, as Strings usam valores em formato ISO-8859–1/Latin-1 que precisam de apenas um byte por caractere. Em outras palavras, poderíamos usar metade do espaço!

Bem, é o que estamos fazendo agora com Java 9! Experimente abrir o JShell e ver como esse campo de valor é declarado hoje:

jshell> String.class.getDeclaredField("value")
	
private final byte[] value;

Um array de bytes!

Com isso usamos apenas um byte, que será o suficiente na esmagadora maioria dos casos. Para os demais, foi adicionado um campo adicional de 1 byte para indicar qual o encoding que está sendo usado. Isso será feito automaticamente, baseado no conteúdo da String.

Essa proposta é conhecida como Compact Strings.

Ufa! Esse é resumo mínimo do que entrou na nova versão, mas acredite quando eu digo que tem muito mais além do que foi aqui mencionado. A própria Oracle amadureceu bastante suas documentações e trabalho na comunidade, com vários artigos e tutoriais bem interessantes. Vou deixar alguns links aqui pra quem quiser se aprofundar mais.

Onde estudar mais?

Entre os documentos oficiais dos arquitetos da plataforma, você certamente poderá se interessar em dar uma olhada nos release notes, com links inclusive para alguns tutoriais de migração, na lista com todas as especificações que entraram, além de alguns videos de experts introduzindo as mudanças.

No livro Java 9: Interativo, reativo e modularizado eu entro a fundo nas principais mudanças colocando tudo em um projeto prático, que no final é modularizado e você sente com as mãos na massa como é o processo de migração e os grandes benefícios da nova arquitetura modular da plataforma.

Também falei um pouco sobre as mudanças em um episódio da Alura Live, junto com o Gabriel — nosso host — e o Phil, que trabalha conosco no time de desenvolvimento da Alura.

Logo você também deve ver mais um monte de conteúdo aberto nosso sobre o assunto, entrando a fundo em detalhes específicos das muitas novidades da versão.

E ai, o que achou das mudanças?

The post O mínimo que você deve saber de Java 9 appeared first on Blog da Caelum: desenvolvimento, web, mobile, UX e Scrum.