Linux e Windows Server, ainda em dúvidas?

Faz anos que a Microsoft namora o Linux, e no ano passado o improvável aconteceu, ela se juntou a Linux Foundation (TLF), mostrando claramente que não ia adiantar muito tentar recuperar o mercado de servidores, atualmente dominado pelo Linux. Azure Runs Linux e Microsoft at Linux Foundation

Então a Microsoft tem seu próprio Linux (Azure Cloud Switch), voltado para o controle e hosting de servidores Windows em sua Nuvem Azure; aqui pra bom entendedor fica uma dica da própria, de que quando a coisa é pra valer, ela se valeu do Linux e, percebendo melhor o futuro, juntou-se à LF. Microsoft desenvolve seu próprio Linux

Muito provável que um leitor desatento ou eufórico vá encontrar dezenas de milhares de artigos, colocando o Windows dominando quase 100% desse mercado de servidores. Mas, tem um porém: como entrar em cada empresa e ver o que se está usando? O mais garantido seria vasculhar os mais de dez milhões de top servers na Internet toda, e que respondem que SO usam. Parece haver um consenso nessa metrificação, dizer o quanto cada um domina no market share pelo exposto na web. Se você pegar um relatório da SpiceWorks, verá um mercado de servidores de 10% Linux e 87% usam Windows Server. Nesse ponto até existe uma ótica que tem lógica, mas não se sustenta: bastam 10% de Linux pra fazer os 90% do Windows. A medição foi feita pelos números de downloads. Na metrificação por survey da W3Techs aparece um resultado totalmente diferente, 65% Linux contra 34% Windows.

O mais estranho nisso tudo, é que nem se discute o que seria mais sensato, como as habilidades do SO. E mais, é inquestionável a superioridade do Linux no que tange a ser um SO voltado para um processamento de alto desempenho, robustez, escalabilidade, multi processamento paralelo distribuído, mais com menos, etc. Difícil é ouvir algo do tipo: “mas eu não tenho gente qualificada em Linux”… nesse momento a luta acabou, jogaram a toalha! Sentimentalismo é coisa que enfraquece a razão.

O Windows foi a melhor coisa que aconteceu no mundo da computação pessoal, inquestionável a contribuição dela na Tecnologia da Informação no passado, no presente e, agora com Linux, no futuro. Mas isso não significa dizer que ela é melhor que um MacOS “casadinho” com o hardware proprietário da Apple, para a computação pessoal, mas o custo quase zero das versões desktops da Microsoft e a vantagem adicional de que não existe concorrente, a tornam ainda imbatível nesse mercado; conheça o Windows primeiro se pretende usar um Mac, você não voltará por livre e espontânea vontade a usar Windows. Fato!

Mais de 70% das empresas estão com seus servidores virtualizados e, nesse nicho o VMWare massacra. E vamos andando, e há coisas que não se pode mais parar, como ir para a Nuvem, que oferecem um ferramental nunca visto para administração de servidores, e como a sustentação para tanta tecnologia vem da comunidade, fica evidente a escolha por SOs que tenham: Confiabilidade, escalabilidade, robustez, alto desempenho e todo um arsenal para suportar infra estrutura, seja no “staging” ou “production“. A resistência não deve estar em usar Linux, que pode conviver tranquilamente com um ambiente Windows, aliás Linux é mesmo o “backend“, deixando a plataforma de desenvolvimento em Windows (bom mesmo seria MacOS!). O SqlServer já foi pra Linux!

According to IDC [1], 47.9% of the servers worldwide ran Windows Server whereas 40.5% ran Linux. W3Techs [2] ran a survey this month, which checked the top 1 million Web servers (according to Alexa) and 64.9% of them were running Unix/Unix-like operating systems, 35.2% were running Windows and less than 0.1% were running Mac.

Então, se olharmos para outras coisas como o aumento do uso e hegemonia de determinadas linguagens de programação, iremos ver Java e JavaScript (e Python!) como líderes e, veremos que as empresas adotaram e adotam Java, tradicionalmente mundo Linux. Não há o que discutir, atualmente e no futuro, Linux ou suas vertentes dominarão esse mercado, assim como Windows continuará a dominar o Desktop. E quem irá fazer isso serão os grandes players de Nuvem, já que aqui por baixo ainda carecem de coragem e conhecimento de Sistemas Operacionais. Mesmo o Windows sendo superior na Nuvem, por baixo tem Linux como hosting.

Mas não só o SO importa tanto, já que uma linguagem precisa ser usada para que a mágica aconteça. O que se observa historicamente é que até um dado momento, o Java estava muito forte nos ambientes acadêmicos, no mundo open source, e entranhado fortemente no governo (quem nunca usou o IRPF da Receita Federal, por exemplo). Antes da abertura do código do .Net, o Java foi fortemente “patrocinado” por algumas das gigantes de tecnologia (IBM, Sun, Oracle e HP) como forma de combater a hegemonia e dependência da Microsoft. A Microsoft por sua vez corria por fora, e era a preferência das empresas produtoras de software “pacote” e desenvolvedores iniciantes, pela maior facilidade de acesso à material oficial e suporte.

Enquanto isso, no emergente ambiente de aplicações móveis, ou mobile, em termos de aplicações nativas, a Microsoft “dormiu no ponto” durante décadas com o arcaico “Windows CE”, e o .Net ainda hoje só acha espaço no Windows Phone, já que o Android essencialmente se utiliza do Java, e no mundo iOS da Apple a linguagem é o Objective-C. Então se formos falar de SOs, e Android é Linux (fork), então já está sanada a dúvida.

É inegável que tanto o Java quanto .Net estão maduros e são performáticos (se bem implementados), e tem promessas de continuidade e de evolução. Mas não existem estatísticas confiáveis e nem consenso sobre qual é o mais utilizado globalmente, dado a grande variedade de cenários de uso e soluções existentes. Dependendo do custo complexidade, tamanho, orçamento e prazo disponível para implantar uma solução, você perceberá que a escolha não é óbvia.

 

Configurando Wildfly com Apache, load balance e clusterização no CentOS7

Esse artigo mostra uma proposição de um ambiente balanceado, clusterizado, full profile HA, usando Apache2 e Wildfly, usando o modo domain para propósitos de gestão.

Para balanceamento e cluster, usaremos o mod_cluster sob o Apache com todas as máquinas rodando sistema operacional CentOS7. Para esse propósito usaremos quatro servidores, distribuídos em:

  • server1: 01 servidor para Apache e mod_cluster;
  • server2: 01 servidor para o domain, Wildfly;
  • server3 e server4: 02 servidores com wildfly para compor o cluster.

Seguiremos uma sequencia de comandos para a configuração dos servidores eapplications server.

Verifique em todos os servidores…

A rede está funcionando? Veja qual IP de cada máquina com “ip addr” ou “ifconfig” e tente “pingar” ou conectar com ssh. O CentOS7 por default deixa a rede desalibilitada.

server1: Instalando Apache2 HTTP

Execute o comando abaixo para a instalação do Apache2:

sudo yum install httpd httpd-devel apr-devel openssl-devel mod_ssl -y

Após a instalação, inicie o serviço.

sudo service httpd start

Acesse no browser de sua máquina se o Apache HTTP Server está no ar, só acessar pelo IP: http://<IP_SERVER1>. Se nenhuma página de testes aparecer, então provavelmente você precisa liberar a porta 80 para o HTTP Server no firewall; veja aqui como configurar.

Baixar e instalar o mod_cluster.

wget http://downloads.jboss.org/mod_cluster//1.3.1.Final/linux-x86_64/mod_cluster-1.3.1.Final-linux2-x64-so.tar.gz

Depois a instalação.

tar -zxvf mod_cluster-1.3.1.Final-linux2-x64-so.tar.gz
sudo cp mod_advertise.so /etc/httpd/modules/
sudo cp mod_manager.so /etc/httpd/modules/
sudo cp mod_proxy_cluster.so /etc/httpd/modules/
sudo cp mod_cluster_slotmem.so /etc/httpd/modules/

Comente a linha do mod_proxy_balancer pois será usado o mod_cluster

cd /etc/httpd/conf.modules.d
vi 00-proxy.conf

Depois de comentada

#LoadModule proxy_balancer_module modules/mod_proxy_balancer.so

Criar e adicionar o conteúdo do arquivo de configuração do cluster, o mod_cluster.conf.

cd /etc/httpd/conf.d/
touch mod_cluster.conf
vi mod_cluster.conf

Adicione o texto abaixo no arquivo mod_cluster.conf

LoadModule cluster_slotmem_module modules/mod_cluster_slotmem.so
LoadModule manager_module modules/mod_manager.so
LoadModule proxy_cluster_module modules/mod_proxy_cluster.so
LoadModule advertise_module modules/mod_advertise.so

MemManagerFile /var/cache/mod_cluster

Maxcontext 100
Maxnode 100
Maxhost 100

<VirtualHost *:80>

	<Directory />
		Order deny,allow
		Allow from all
	</Directory>

	<Location /mod_cluster_manager>
		SetHandler mod_cluster-manager
		#Order deny,allow
		#Deny from all
		#Allow from all
		AuthType Basic
		AuthName "MCM"
		AuthUserFile /etc/httpd/modclusterpassword
		Require user admin
	</Location>

	KeepAliveTimeout 60
	MaxKeepAliveRequests 0
	ServerAdvertise Off
	EnableMCPMReceive Off

</VirtualHost>

Criar um usuário com senha para o mod_cluster com o singelo nome de “admin”.

sudo htpasswd -c /etc/httpd/modclusterpassword admin

Fazer uma reciclagem do Apache.

sudo service httpd stop
sudo service httpd start

Testar novamente no browser: http://<IP_SERVER1>

Testar se o mod_cluster foi corretamente instalado e está respondendo: http://<IP_SERVER1>/mod_cluster_manager

server2, server3 e server4: Instalando e configurando Java e Wildfly

Baixar, instalar e configurar o Java

wget --no-check-certificate --no-cookies --header "Cookie: oraclelicense=accept-securebackup-cookie" http://download.oracle.com/otn-pub/java/jdk/7u80-b15/jdk-7u80-linux-x64.rpm
sudo rpm -Uvh jdk-7u80-linux-x64.rpm
sudo alternatives --install /usr/bin/java java /usr/java/latest/jre/bin/java 200000
sudo alternatives --install /usr/bin/javaws javaws /usr/java/latest/jre/bin/javaws 200000
sudo alternatives --install /usr/bin/javac javac /usr/java/latest/bin/javac 200000
sudo alternatives --install /usr/bin/jar jar /usr/java/latest/bin/jar 200000

Baixar o Wildfly

wget http://download.jboss.org/wildfly/8.1.0.Final/wildfly-8.1.0.Final.tar.gz

Instalar Wildfly

tar xzf wildfly-8.1.0.Final.tar.gz
sudo mv wildfly-8.1.0.Final /opt
cd /opt
sudo ln -sf wildfly-8.1.0.Final/ wildfly

Configurar um usuário no Linux, o wildfly

sudo groupadd wildfly
sudo useradd -s /bin/bash -d /home/wildfly -m -g wildfly wildfly
sudo chown -R wildfly:wildfly /opt/wildfly-8.1.0.Final
sudo chown -h wildfly:wildfly /opt/wildfly

Alterar a permissão do usuário “wildfly” para administrador do Linux (cuidado!) acrescentando a linha logo abaixo.

sudo visudo
wildfly ALL=(ALL) NOPASSWD:ALL

Depois criar password e entrar como usuário “wildfly”

sudo passwd wildfly
su wildfly

Configurar o Wildfly

sudo cp /opt/wildfly/bin/init.d/wildfly.conf /etc/default/

Editar o arquivo de configuração e descomente as linhas abaixo

sudo vim /etc/default/wildfly.conf
## Location of WildFly
JBOSS_HOME="/opt/wildfly"

## The username who should own the process.
JBOSS_USER=wildfly

Configurar o Wildfly como um serviço

sudo cp /opt/wildfly/bin/init.d/wildfly-init-redhat.sh /etc/init.d/wildfly

Iniciar o Wildfly

sudo service wildfly start

Veja no log se não algum erro

more /var/log/wildfly/console.log

Parar o Wildfly

sudo service wildfly stop
server2: configurando o Wildfly Master Domain

Configurar o Wildfly Master

sudo vi /etc/default/wildfly.conf

Altere as linhas abaixo

JBOSS_MODE=domain
JBOSS_DOMAIN_CONFIG=domain.xml
JBOSS_HOST_CONFIG=host-master.xml
STARTUP_WAIT=30
SHUTDOWN_WAIT=30
JBOSS_CONSOLE_LOG=/var/log/wildfly/console.log

Faça login como usuário “wildfly” se já não estiver

su wildfly

Configurar  o parâmetro jboss.bind.address.management, adicionando junto com as outras linhas de JAVA_OPTS

vi /opt/wildfly/bin/domain.conf
JAVA_OPTS="$JAVA_OPTS -Djboss.bind.address.management=<IP_DA_MAQUINA>"

Configurar os nomes do domínio

vi /opt/wildfly/domain/configuration/domain.xml

De…

<server-groups>
 [...]
</server-groups>

Para…

<server-groups>
   <server-group name="arquitetura-grupo-1" profile="full-ha">
    <jvm name="default">
      <heap size="512m" max-size="512m"/>
      <permgen max-size="256m"/>
    </jvm>
    <socket-binding-group ref="full-ha-sockets"/>
   </server-group>
</server-groups>

Criar um usuário dentro do WildFly para comunicação no modo domain, usaremos depois; siga a sequência abaixo.

sh /opt/wildfly/bin/add-user.sh
[enter]
wuser
sapucaia@1
sapucaia@1
[enter]
yes
yes

Anotar o secret gerado após criar o usuáro pois será usado adiante

more /opt/wildfly/domain/configuration/host-slave.xml | grep secret
<secret value="c2xhdmVfdXNlcl9wYXNzd29yZA=="/>

Criar um usuário para acessar a web console

sh /opt/wildfly/bin/add-user.sh
[enter]
domainadmin
sapucaia@1
sapucaia@1
[enter]
yes
no
server3 e server4: configurando o Wildfly como host-slave

Configurar o Wildfly para modo host-slave

sudo vi /etc/default/wildfly.conf

Alterar as linhas abaixo

JBOSS_USER=wildfly
JBOSS_MODE=domain
JBOSS_HOST_CONFIG=host-slave.xml
STARTUP_WAIT=30
SHUTDOWN_WAIT=30
JBOSS_CONSOLE_LOG=/var/log/wildfly/console.log

Adicionar as linhas de JAVA_OPTS para o domain

vi /opt/wildfly/bin/domain.conf

 

JAVA_OPTS="$JAVA_OPTS -Djboss.domain.master.address=<IP MASTER>" 
JAVA_OPTS="$JAVA_OPTS -Djboss.bind.address=<IP MAQUINA>"

Configurar o slave

vi /opt/wildfly/domain/configuration/host-slave.xml

Adicionar name no <host (no server03 adicione host1, no server4 adicione host2)

<host name="host1-wildfly" xmlns="urn:jboss:domain:2.1">

Alterar o secret para o mesmo do Master Domain

<secret value="c2xhdmVfdXNlcl9wYXNzd29yZA=="/>

Adicionar o username

<domain-controller>
    <remote host="${jboss.domain.master.address}" username="wuser" port="${jboss.domain.master.port:9999}" security-realm="ManagementRealm"/>
</domain-controller>

Alterar o servers para: (no server03 adicionar arquitetura-1, no server04 adicionar arquitetura-2)

<servers>
   <server name="arquitetura-1" group="arquitetura-grupo-1"/>
</servers>

Conectando o Wildfly ao Apache Web Server

No Servidor server-domain-widfly edite o arquivo /opt/wildfly/domain/configuration/domain.xml. Busque pele profile <profile name=”arquitetura-full-ha”>. Dentro desse profile edite o Subsystem <subsystem xmlns=”urn:jboss:domain:modcluster:1.2″> deixando-o como abaixo:

<subsystem xmlns="urn:jboss:domain:modcluster:1.2">
  <mod-cluster-config advertise-socket="modcluster" proxy-list="<IP_MOD_CLUSTER>:80" advertise="false" sticky-session="true" load-balancing-group="arquitetura"  connector="ajp">
   <dynamic-load-provider>
     <load-metric type="cpu"/>
   </dynamic-load-provider>
  </mod-cluster-config>
</subsystem>

Observe que na tag proxy-list nós colocamos os Balancer(s) / Apache Web Servers. Acesse o mod cluster manager para visualizar as instâncias conectadas nos Balancers.

 

 

 

 

 

 

 

 

 

 

 

Multiple Instances of WildFly on Different Ports on Same Machine

WildFly can be started on the default port 8080 using:

./bin/standalone.sh

The default landing page is then accessible at localhost:8080 and looks like:

tt1-wildfly-welcome

The default admin console is accessible at localhost:9990/console and looks like:

tt8-admin-console

Do you want to start another WildFly standalone instance on the same machine on a different port ?

./bin/standalone.sh -Djboss.socket.binding.port-offset=1000

will start another standalone server on port 8080 + 1000. And so the landing page is now accessible at localhost:9080. Similarly, admin console is now accessible at localhost:10990/console.

Similarly, you can start multiple instances by specifying port offset.

Be Sociable, Share!

Java 8 : Default method in Interface

Original article here:

This article contains…

  • What is Default methods ?
  • Why Default methods ?
  • Example of various scenarios using Default methods
  • Default methods and multiple inheritance
  • Behavior when extending interface.

Introduction:

In the Java programming language, an interface is a reference type, similar to a class, that can contain only constants, method signatures, static methods, and nested types. Method in an Interface does not have a body, and they are implicitly public abstract by default.

Wait, Above definition of interface was correct up to Java 7. In Java 8 release, Definition of interface is a bit broader then previous one.

From java 8, Interface can have default methods also.

What is Default Method ?

The method with default implementation in interface are Default methods, they can have body part also and these are non-abstract methods. These methods are useful to provide default implementations.

It can be inherited in the class which implements the interface and it can be Overridden also.

You specify that a method definition in an interface is a default method with the default keyword at the beginning of the method signature. All method declarations in an interface, including default methods, are implicitly public, so you can omit the public modifier.

Why Default method ?

Suppose at some point you want to add new functionality in declared interface, up to Java 7, If you will add a new method in declared an interface, you also have to define the implementation of the method in classes that are implementing that interface.

In java 8, You can add a default method containing the implementation and all the child class will inherit that method.

Bulk data operation in collection is added in Java 8 (Reference : http://openjdk.java.net/jeps/107), to implement that forEach() method is added in Collection interface. If we are adding abstract method in Collection interface, that will break all the existing code because each class has to implement that method.

Solving the issue, following default forEach() method is added in Collection interface,

interface Collection {
   default void forEach(Block action) {
      for (T t : this)
      action.apply(t);
   }
}

Example of default method :

interface HasBody {
   default void first() {
      System.out.println("This is first default method in HasBody interface.");
   }

   default void second() {
      System.out.println("This is second default method in HasBody interface.");
   }

   void third();
   }

class Demo implements HasBody {

   @Override
   public void second() {
      System.out.println("Overriding default method in child class.");
   }

   @Override
   public void third() {
      System.out.println("This is implemented abstract method of an interface.");
   }

   public void implement() {
      HasBody ref = new Demo();
      // Calling first() default method declared in HasBody interface.
      ref.first();

      // Calling Overridden default method of HasBody interface.
      ref.second();

      // Calling implemented method of HasBody interface.
      ref.third();
   }
}

In above example, there are three scenarios,

  1. first() method is default method in HasBody interface and Inherited in DefaultMethodDemo class.
  2. second() method is default method in HasBody interface and Overridden in DefaultMethodDemo class.
  3. third() method is abstract method in HasBody interface and Implemented in DefaultMethodDemo class.

Multiple inheritance and Default methods:

As the default methods in interface will be inherited in class that will implement interface and a class can implement more than one interface that may contain same method that defined default in interface. Multiple inheritance will be into the picture and because of that, ambiguity may be created.

Well, this situation is handled compile time in JDK 8

Example :

interface CreateAmbiguityOne {

   default void abc() {
      System.out.println("This method will create ambiguity.");
   }
}

interface CreateAmbiguityTwo {

   default void abc() {
      System.out.println("This method will create ambiguity.");
   }
}

class AmbiguousChild implements CreateAmbiguityOne,CreateAmbiguityTwo {
   // Ambiguouity in class.
}

Above code will not compile, Error will be

class Child inherits unrelated default for abc() from types CreateAmbiguityOn and CreateAmbiguityTwo.

However, Overriding abc() method in Child class will solve above ambiguity.

class Child implements CreateAmbiguityOne, CreateAmbiguityTwo {
   @Override
   public void abc() {
      System.out.println("Overriding abc() will solve Ambiguity.");
   }
}

Another point to note is extending a class that contains same method as default method in interface will not create ambiguity.
because Child class will Override the default method of interface by inherited method of Parent class.

Example :

class Parent {
   public void abc() {
      System.out.println("This method will override default method of interface in child class.");
   }
}

class ChildTwo extends Parent implements CreateAmbiguityOne {
   // This class has no ambiguity even if Parent class and CreateAmbiguityOne has same method.
   // Because,
   // Inherited abc() method of Parent class will Override default method of CreateAmbiguityOne in ChildTwo class.
}

Behavior of default method when we extend interface.

  • All the default methods of interface will be inherited in child interface.
  • Child interface can override the default method.
  • Child interface can declare default method of parent interface as abstract, that will force implementing class to Override the default method.

Example :

interface ChildInter extends HasBody {
   // All the default methods of HasBody interface will be inherited here.

   // Override the default method in child interface.
   default void first() {
      System.out.println("first() method is overriden in child interface.");
   }

   // Redefine the default method as abstract that will force subclass to Override the method.
   abstract void second();
}

class DemoTwo implements ChildInter {
   @Override
   public void second() {
      System.out.println("Subclass overriding default method of HasBody interface redefined in ChildInter.");
   }

   @Override
   public void third() {
      System.out.println("abstract method of HasBody interface.");
   }
}

More articles will be available soon on Java 8 and SCJP.

You can always clone the executable code of article posted on Java By Examples from github.com
Repository URL : https://github.com/ksarsecha/java8_in.git

– See more at: http://java8.in/java-8-default-method-in-interface/#sthash.6YlezEBk.dpuf

JAVA 8: Streaming a String

Streaming a String using Java 8.

public static void main(String[] args) {
        "hey duke".chars().forEach(c -> System.out.println((char)c));
    }

The parallel version does not preserve the order (and comes with additional overhead):

public static void main(String[] args) {
        "hey duke".chars().parallel().forEach(c -> System.out.println((char) c));
    }

Enjoy Java 8!