SOA Arquitetura Orientada a Serviços

Surgimento

Conforme relatado no post de SOAP, no início as páginas da internet eram todas estáticas, contendo HTMLs não reativos as ações dos usuários. Depois de algum tempo, com o surgimento do javascript, começaram a aprecer a Web 2.0, as as páginas dinâmicas.
Estas páginas dinâmicas foram construídas em cima de uma arquitetura distribuída e conforme os anos foram passando, as empresas notaram que poderiam ganhar dinheiro provendo dados para seus clientes. Neste ponto, os sistemas começaram a se abrir mais e as empresas começaram a expor alguns dados.
Esta exposição de dados foi realizada através de serviços na Web, e existem vários exemplos de serviços abertos na web.
Com isto, todos os dados das empresas começaram a ser expostos, tanto externamente, quanto internamente, por serviços web e assim surgiu o SOA que é uma arquitetura distribuída onde todos os dados são expostos através de serviços.

Caraterísticas

O SOA surgiu para substituir os RPCs, pois as empresas precisavam de algo mais dinâmico e mais fácil de ser acessado.
Os serviços web, podem ser acessados por praticamente qualquer linguagem de programação, basta que ela consiga fazer uma chamada HTTP e consiga decodificar JSONs ou XMLs.
Ao usar SOA deve-se expor as interfaces dos seus serviços, ou os contratos e uma forma muito comum de expor estes serviços, quando usamos o protocolo SOAP, baseado em xml, é usarmos a WSDL (Web Service Description Language), ou linguagem de descrição do Web Service.
O WSDL é uma linguagem de metadados, ou seja, dados sobre os dados, e acessando o WSDL de um serviço é possível gerar código, na sua linguagem de preferencia, que traduzem o acesso aqueles webservices.
Dentre os dados, que estão disponíveis no WSDL temos a lista dos serviços disponíveis, assim como om qual método HTML ele é acessado, e os atributos, e seus tipos, daquele serviço.
Com o SOA é possível isolar bem as partes de um software web, casando muito bem com a arquitetura de 3 camadas, ou o MVC. Em um software SOA, os desenvolvedores fazem os serviços, que serão acessados pelos WebDesigners, os quais ficarão responsáveis por desenvolver a iteração com o usuário.

Link pra apresentação

Ferramenta de build Gradle

Neste post será mostrado como instalar e como criar o seu primeiro projeto usando o build tool Gradle.

Preparação do ambiente

Para instalar o Gradle, antes devemos instalar o sdkman, que é uma ferramenta para administrar múltiplos ambientes de desenvolvimento e sua instalação é bem simples, basta digitar o seguinte comando no terminal:

curl -s "https://get.sdkman.io" | bash

 Após completar a instalação você deverá abrir um novo terminal para que o comando sdk seja reconhecido.

Instalação do Gradle

Depois de ter instalado o sdkman, agora podemos instalar o gradle. A sua instalação é bem simples, basta digitar o seguinte comando no terminal:

 sdk install gradle 4.1*

* Nota, quando este blog foi escrito, a versão estável do gradle era a 4.1, consulte a página do gradle para saber qual é a última versão estável.

Criando o seu primeiro projeto Java

Depois da instalação, agora vamos criar o primeiro projeto Java usando o gradle, para isto primeiro devemos criar um diretório para ele, o que será feito com o seguinte comando:

mkdir exemplo-gradle

Agora devemos entrar no diretório que acabamos de criar:

cd exemplo-gradle

Aqui vamos inicializar o nosso primeiro projeto gradle

 gradle init --type java-application

Init é o comando do gradle para criar um projeto, no type está sendo definido o tipo do projeto, que no caso é uma aplicação Java.
Para fazer o build deste projeto teste basta digitarmos:

gradle build

A ferramenta gradle irá compilar o nosso projeto e verificar se não existem erros de compilação.

Configurando o gradle com a sua IDE

Para configurar o gradle para executar com o eclipse, basta adicionar:

plugins {
    id 'eclipse'
}

Ao arquivo build.gradle do seu projeto, depois disto digite

gradle eclipse

Que a ferramenta irá criar os arquivos do eclipse no seu projeto e com isto é possível você importar o build dentro do eclipse.

Criando um projeto play

Para criar um projeto com o play, devemos criar um diretório e depois adicionar o seguinte conteúdo no arquivo build.gradle, que estará dentro deste diretório:

plugins {

    id 'play'

}

repositories {

    jcenter()

    maven {

        name "typesafe-maven-release"

        url "https://repo.typesafe.com/typesafe/maven-releases"

    }

    ivy {

        name "typesafe-ivy-release"

        url "https://repo.typesafe.com/typesafe/ivy-releases"

        layout "ivy"

    }

}

Além de adicionar o plugin do play no início do arquivo, devemos também adicionar os repositórios da typesafe, que é quem faz o play framework, no arquivo de build.

Comandos úteis do Gradle:

Dependendo dos plugins utilizados no seu projeto, os comandos disponíveis no gradle irão mudar, portanto, para saber quais comandos estão disponíveis utilizamos o comando tasks:

gradle tasks

Este comando irá mostrar quais são as opções disponíveis para o gradle, além de mostrar um texto explicativo do que é cada um deles.

 Comandos úteis

gradle init -> inicializa um projeto no diretório corrente

gradle build -> compila o código do projeto

 

Exercicios de Segurança

1. Desenvolva os sistemas de segurança desta arquitetura, incluindo as redes, a separação das máquinas, os firewalls. Onde estarão eles, as máquinas, como estarão distribuídas. Partindo de um sistema distribuído de tenha
• 1 Proxy
• 2 Webservices
• 3 Caches
• 2 Bds
• 2 Servidores de Aplicativos
2.  Considerando um sistema pós ataque, mesmo que os arquivos de log tenham sido apagados, como você tentaria investigar/descobrir como o sistema foi invadido?
3. Escolha um tipo de design e desenvolva uma política de segurança para um sistema de gerenciador de emails.

Introdução a Sistemas Distribuídos

Introdução a Sistemas Distribuídos 

História

Conforme as máquinas foram evoluindo, os sistemas foram ficando mais complexos, tudo na história da computação começou com enormes máquinas de válvulas, que eram programadas bit a bit, acionando ou não uma válvula. Com a evolução das máquinas, os sistemas também tiveram que evouir.
No começo todo o sistema rodava em uma única máquina, mas com o passar do tempo, os sistemas já não cabiam mais nas máquinas e os sistemas tiveram que evoluir para uma forma em que eles pudessem rodar em várias máquinas, afim de distribuir o processamento e dar conta de todas as requisições.
No início as linguagens tinham suas próprias formas de armazenar os dados e todo o programa rodava sozinho, sem depender de nenhum software externo. Tudo rodava em máquinas grandes e terminais burros acessavam os programas, na maioria das vezes os terminais eram apenas um teclado e um monitor.

Como começou?

Com o tempo, foram se criando formas de armazenar os dados, e um software para cuidar disto. Os bancos de dados surgiram na década de 70, e os Sistemas Gerenciadores de Banco de Dados (SGBD) relacionais, começaram a dominar o mercado na década de 80. No início cada banco tinha o seu modo de acesso, depois de um tempo SQL foi adotado como padrão para todos eles. 

Estes bancos são transacionais e possuem um relacionamento entre as tabelas. As transações são consideradas ACID:

• Atomicas: Todas as ações de uma transação devem ser completadas com sucesso para que a transção seja comitada.
• Consistência: As regras de consistência são definidas no banco e todas elas devem ser obedecidas para que uma transção seja completada. (not null, foreign key, etc)
• Isolamento: Uma transação é completamente isolada de outra transção e nenhuma outra transação no banco poderá interferir na transação corrente.
• Durabilidade: Os dados de uma transação são permanentes e as alterações realizadas por ela só podem ser apagadas se isto for parte de uma transação subsequente.

Com a divisão entre um software para regras de negócio, processar a entrada de dados e um outro para cuidar dos dados iniciou-se a era dos sistemas distribuídos. A partir de agora um software cuidava do armazenamento dos dados e outro cuidava da entrada e da formatação dos dados.
As redes evoluiram e as empresas começaram a investir em servidores, com isto os terminais executavam uma boa parte do processamento dos dados e estes sistemas eram chamados de cliente servidor. Os softwares eram compilados para uma plataforma específica e eles deviam ser instalado em todas as máquinas que iriam usá-lo. A cada atualização uma nova rodada de instalação deveria ser feita.

A evolução para a web

Com o surgimento da internet, os sistemas voltaram a ser executados em um serviço central e os browsers acessavam os sistemas, com quase nenhum processamento.

As interfaces foram evoluindo e hoje parte das regras de negócio são validadas e executadas pelos browsers.

Devido a facilidade de instalação e manutenção os sistemas web ocuparam o lugar que todos os sitemas dentro de uma empresa e hoje ao invés de instalar um software, todos estão desenvolvendo um site com um sistema.

A cada dia que passa os sistemas foram ficando maiores e mais complexos e eles foram sendo divididos em várias camadas, todas as camadas possuem réplicas e são distribuídas, com isto os sistemas se tornaram cada dia mais disponíveis.

Os bancos de dados já não são mais a única forma de ser armazenar os dados, muitos sistemas de armazenamento NoSQL e NewSQL são utilizados, existem alguns tipos diferentes e cada um deles possui uma peculiaridade que o torna ideal para uma demanda específica.

Pontos Importantes

Comunicação para um sistema distribuído funcionar as máquinas precisam de uma forma confiável de comunicação.

Tolerância a falhas, como o sistema é constituído de vários componentes, se algum deles falhar o sistema deve que continuar operando normalmente.

Os componentes dos sistemas distribuídos possuem nomes, então uma forma organizada de nomear estes componentes precisa ser aplicada.

Quando temos que armazenar uma grande quantidade de dados, um sistema de arquivos distribuídos deverá ser usado.

Ao desenvolver um sistema distribuído a sua arquitetura deverá ser pensada de forma a atingir o melhor desempenho, com a garantia de que o sistema não vai parar, no menor custo, o que é uma tarefa bem complicada.

Apresentação