Automação de criação e implementação é crucial para a execução tranquila de qualquer projeto de desenvolvimento. Conforme os projetos ficam maiores, isso se torna mais importante. Uma tendência recente em application life cycle management tools (ALM) é construir uma melhor conexão entre desenvolvimento e operações e, em particular, a integração dessas ferramentas com as nuvens.

Uma das coisas maravilhosas dos recursos em nuvem em comparação com os recursos físicos é a possibilidade de criar recursos em nuvem sob demanda com APIs. As ferramentas ALM podem ser executadas na nuvem, aproveitar a nuvem de alguma maneira ou ser usadas para desenvolver aplicativos para a nuvem.

O IBM Rational® Desenvolvedor de aplicativos e ferramentas de desenvolvimento integradas são ideais para desenvolvimento de código, incluindo a realização de testes de unidade e construções locais, mas a criação de um processo de criação repetível é fundamental para o desenvolvimento de aplicativos em uma equipe maior que uma pessoa.

Há várias tarefas que frequentemente são agregadas ao ciclo de vida de criação e implementação, incluindo:

• compilação
• empacotamento
• validação
• teste de unidade
• configuração de middleware
• implementação

Em computação em nuvem, é possível levar a automação de implementação um passo adiante criando máquinas virtuais com software pré-instalado.

Há várias ferramentas de criação de software livre e comerciais que têm capacidade automação de criação e implementação, incluindo Ant, Maven e IBM Build Forge. neste artigo, focamos na ferramenta de software livre Apache Maven; ela tem definições para as fases da criação e implementação em que estamos interessados e inclui uma estrutura extensível. Além disso, contém padrões para várias melhores práticas e plug-ins para diversas tarefas de criação que são úteis.

Projeto J2EE de amostra

O catálogo IBM SmartCloud Enterprise inclui instâncias do IBM WebSphere® Application Server 7.0. Com isso, é possível usar um ambiente J2EE sem precisar instalar nenhum software e também desfrutar dos recursos extras que o WebSphere Application Server fornece além dos outros ambientes J2EE.

Ao solicitar um servidor WebSphere Application Server, você é solicitado a fornecer um nome de usuário e senha para o console de administração WebSphere Application Server. Anote isso porque será preciso mais tarde. Além disso, você será solicitado a escolher o perfil, como mostrado aqui.

Um perfil do WebSphere define um ambiente de tempo de execução, incluindo todos os arquivos que o servidor processa para determinar e armazenar informações de configuração. Escolha o perfil Development . Ele tornará o WebSphere Application Server mais conveniente para gerenciar através do IBM Rational Software Architect, como discuto mais adiante.

O WebSphere Application Server é iniciado por um breve período após a instância ter sido fornecida e inicializada. É possível visualizar o console de administração com este URL: https://host:9043/ibm/console/logon.jsp.

Todo o gerenciamento do WebSphere Application Server, exceto por iniciar e parar o servidor em si, pode ser feito a partir do console de administração da Web. É possível usar o IBM Rational Application Developer, o Eclipse ou vários outros ambientes de desenvolvimento integrados para criar aplicativos J2EE que possam executar no WebSphere Application Server. Para o Eclipse, use as Ferramentas Padrão J2EE, também conhecidas como J2EE versão Ferramentas do Desenvolvedor. Você também pode usar as imagens do IBM Rational Application Developer no catálogo IBM Cloud para aproveitar um ambiente pré-construído.

Para testá-lo no Rational Application Developer ou no Rational Software Architect, inicie um novo aplicativo corporativo no Eclipse usando o assistente de Projeto do Aplicativo EAR:

Chame o projeto CloudAPIClientEAR. Clique no botão Finish . A seguir, crie um projeto da web dinâmico; chame-o para CloudAPIClientWeb. Adicione o projeto da web dinâmico ao projeto CloudAPIClientEAR:

Agora vamos criar um arquivo HTML e um servlet para testar o aplicativo. Adicione um arquivo chamado index.html ao diretório de conteúdo da web com algum texto como "Meu aplicativo da Web". Ainda, adicione um servlet com código como a classe TestServlet:

package com.ibm.cloud.examples.servlet;

import java.io.IOException;
import java.io.Writer;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * Classe de implementação do Servlet TestServlet
 */
public class TestServlet extends HttpServlet {
     private static final long serialVersionUID = 1L;

     protected void doGet(HttpServletRequest request, HttpServletResponse response) 
       throws ServletException, IOException {
          Writer writer = response.getWriter();
          writer.write("My web application");
     }
}

Se você usava o Rational Software Architect ou o Eclipse, seu arquivo web.xml do archive do aplicativo da web já deve estar configurado para você. Se não estiver, ele pode se parecer com isto:

<?xml version="1.0" encoding="UTF-8"?>
<web-app id="WebApp_ID" version="2.5" 
 xmlns="http://java.sun.com/xml/ns/javaee" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
     <display-name>CloudAPIClientWeb</display-name>
     <servlet>
          <display-name>TestServlet</display-name>
          <servlet-name>TestServlet</servlet-name>
          <servlet-class>com.ibm.cloud.examples.servlet.TestServlet</servlet-class>
     </servlet>
     <servlet-mapping>
          <servlet-name>TestServlet</servlet-name>
          <url-pattern>/TestServlet</url-pattern>
     </servlet-mapping>
     <welcome-file-list>
          <welcome-file>index.html</welcome-file>
     </welcome-file-list>
</web-app>

A seguir, exporte o arquivo. Clique como botão direito no projeto EAR e escolha Export to EAR. Atribua o nome de CloudAPIClientEAR.ear ao arquivo:

Para adicionar seu arquivo EAR do aplicativo corporativo:

1. Acesse o console de administração do WebSphere no seu navegador.
2. Navegue para Applications > New Application > New Enterprise Application e escolha Upload from Local file system. Carregue o arquivo EAR e clique em Next.
3. Escolha a opção Fast Path .
4. Escolha qualquer diretório para instalar o aplicativo.
5. No painel Map Modules to Servers, selecione CloudAPIClientWeb.
6. Salve as alterações.
7. Acesse Applications > Application Types > WebSphere enterprise applications. Inicie o aplicativo.

Navegue para esta URL para visualizar a página HTML: http://host:9080/CloudAPIClientWeb/. Deve ser possível ver o texto "My web application" que você adicionou à página HTML acima. Para ver o servlet, insira este URL: http://host:9080/CloudAPIClientWeb/TestServlet. Deve ser possível ver o texto que você emitiu a partir de Writer no código TestServlet .

Implementar dessa maneira pode se tornar cansativo se você fizer isso mais de algumas maneiras. É possível economizar muito tempo usando os recursos de implementação remota no Eclipse ou IBM Rational Application Developer. Publicará automaticamente seu aplicativo J2EE para o servidor, em vez de exigir que você passe por todas as telas no console de administração do WebSphere. Use o assistente New Server para adicionar o servidor remoto, fornecendo o nome de host ou o endereço IP, o ID do usuário e senha de administração.

Agora vamos ver a configuração e usar o Apache Maven para facilitar a automação de criação.

Voltar para parte superior

Automação de criação com Maven

Para configurar o Apache Maven, faça o download do website do projeto e defina as variáveis de ambiente como mostrado.

set M2_HOME=D:\opt\apache-maven-3.0.3
set JAVA_HOME=D:\Program Files\IBM\SDP\jdk
set PATH=%JAVA_HOME%;%PATH%;%M2_HOME%\bin

É possível realizar a tarefa equivalente para o Linux®. Para verifique se o Maven está disponível, execute o seguinte comando:

>mvn --version
Apache Maven 3.0.3 (r1075438; 2011-03-01 01:31:09+0800)
Maven home: D:\opt\apache-maven-3.0.3
Java version: 1.6.0, vendor: IBM Corporation
Java home: D:\Program Files\IBM\SDP\jdk\jre
Default locale: en_US, platform encoding: GB18030
OS name: "windows xp", version: "5.1 build 2600 service pack 3", 
 arch: "x86", family: "windows"

Você deve ver algo como as informações que aparecem depois do comando na Listagem 4.

No Maven, um arquétipo é um modelo para um projeto que inclui uma estrutura de projeto padrão que pode ser gerada. É bom saber disso; em nossos exemplos anteriores, você já tinha o próprio projeto criado no ambiente de desenvolvimento integrado e estava criando aplicativos da web e corporativos. Agora vamos ver como abordar isso e aprender um pouco mais sobre o Maven no processo.

No Maven, uma dependência, como uma biblioteca Java™ empacotada em um JAR, inclui pelo menos um groupId, um artifactId, uma versão e um scope. Para dependências de processo, o Maven procura no repositório local. Se a dependência não existir no repositório local, ela será transferido por download de um repositório externo para o repositório local. O repositório externo padrão está em http://repo1.maven.org/maven2/. É possível configurar seu próprio repositório remoto também, e a nuvem será um bom lugar para fazer isso.

Suponha que você tenha uma dependência em um arquivo JAR de terceiros. É possível adicioná-lo ao seu pom.xml com uma sub-rotina como:

<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.12</version>
  <scope>compile</scope>
</dependency>

Esse exemplo é para a biblioteca log4j.

Por questões de licenciamento, as bibliotecas J2EE e relacionadas não estão automaticamente disponíveis. Será preciso acessar o website relevante, concordar com os termos e condições e fazer o download dos arquivos JAR você mesmo. Então use este comando:

> mvn install:install-file -Dfile=/opt/apache-tomcat70/lib/servlet-api.jar 
  -DgroupId=javax -DartifactId=servlet-api -Dversion=3.0 -Dpackaging=jar

Este exemplo são as APIs do servlet necessárias para compilar um projeto da web J2EE. Para criar um aplicativo da web com as estruturas de projeto padrão, digite o comando:

> mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes 
  -DarchetypeArtifactId=maven-archetype-webapp 
  -DgroupId=com.iotdata -DartifactId=my-webapp

O Maven cria a árvore do projeto no my-webapp do diretório, incluindo o arquivo pom.xml. Não vamos fazer isso; em vez disso, vamos usar o projeto que já foi criado na seção anterior. Adicione o arquivo pom.xml ao diretório superior do seu projeto de aplicativo da Web:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
   http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.iotdata</groupId>
  <artifactId>CloudAPIClientWeb</artifactId>
  <packaging>war</packaging>
  <version>1.0</version>
  <name>IoT Data Cloud API Client Web</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>javax</groupId>
      <artifactId>servlet-api</artifactId>
      <version>3.0</version>
      <scope>provided</scope>
    </dependency>
  </dependencies>
  <build>
    <finalName>${pom.artifactId}</finalName>
    <sourceDirectory>src</sourceDirectory>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <configuration>
          <warSourceDirectory>WebContent</warSourceDirectory>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Observe que o pacote é um pacote WAR. O arquivo pom.xml usa o plug-in WAR do Maven que cria o pacote WAR. A estrutura do diretório é um pouco diferente da estrutura padrão, então adicione a identificação sourceDirectory , que é uma propriedade de build . Observe que foi usada a dependência para a API do servlet descrita anteriormente. O scope está configurado para provided de modo que não seja possível copiar o JAR da API do servlet para o aplicativo da Web.

Para construir isso, altere os diretórios para my-webapp e digite este comando:

> mvn package

É possível encontrar a saída no arquivo CloudAPIClientWeb.war no diretório de destino. Implemente isso no seu servidor de aplicativos, aponte o navegador para http://host:8080/CloudAPIClientWeb, e deverá ver uma página com o texto "Hello World!"

É possível gerenciar vários projetos de dentro de uma única estrutura de arquivos Maven usando vários arquivos pom.xml. Você desejará fazer isso por que o aplicativo da web será incluído em um aplicativo corporativo.

Crie um arquivo pom.xml como aquele mostrado na Listagem 10 acima dos diretórios CloudAPIClientEAR e CloudAPIClientWeb.

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.iotdata</groupId>
  <version>1.0</version>
  <artifactId>app</artifactId>
  <packaging>pom</packaging>
  <modules>
    <module>CloudAPIClientWeb</module>
    <module>CloudAPIClientEAR</module>
  </modules>
</project>

Isso define módulos para cada um dos projetos CloudAPIClientweb e CloudAPIClientEAR.

A Listagem 11 mostra como criar um arquivo pom.xml para o projeto EAR:

<project xmlns="http://maven.apache.org/POM/4.0.0" 
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
       http://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>com.iotdata</groupId>
    <artifactId>app</artifactId>
    <version>1.0</version>
  </parent>
  <groupId>com.iotdata</groupId>
  <artifactId>CloudAPIClientEAR</artifactId>
  <packaging>ear</packaging>
  <version>1.0</version>
  <name>IoT Data Cloud API Client EAR</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
     <groupId>com.iotdata</groupId>
     <artifactId>CloudAPIClientWeb</artifactId>
     <version>1.0</version>
     <type>war</type>
    </dependency>
  </dependencies>
  <build>
    <finalName>${pom.artifactId}</finalName>
    <plugins>
     <plugin>
       <groupId>org.apache.maven.plugins</groupId>
       <artifactId>maven-ear-plugin</artifactId>
       <version>2.4</version>
       <configuration>
         <earSourceDirectory>
          ${basedir}
         </earSourceDirectory>
         <modules>
           <webModule>
            <groupId>com.iotdata</groupId>
            <artifactId>CloudAPIClientWeb</artifactId>
            <bundleFileName>
              CloudAPIClientWeb.war
            </bundleFileName>
           </webModule>
          </modules>
       </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Esse arquivo pom.xml define um pai que faz referência ao pom.xml de nível superior. Também é preciso adicione essa sub-rotina ao pom.xml da Web. Desta vez o valor do pacote é ear e usa o plug-in de archive corporativo do Maven. Ele define o modelo da web a parti do projeto da web de antes.

Agora limpamos e reconstruímos todo o projeto com este comando:

> mvn clean install

O EAR é construído e inclui o arquivo WAR do aplicativo da Web.

É assim que se constrói uma criação que pode ser reproduzida. Isso é importante porque em ambientes de teste e produção, os desenvolvedores não têm permissão para conectarem-se ao servidor de aplicativos com seus ambientes de desenvolvimento integrados.

Agora vamos examinar como gerar um plug-in Maven que permite automatizar a criação e a implementação do servidor.

Voltar para parte superior

Plug-in Maven para automação de criação e implementação de servidor

Na seção Automação de criação com o Maven, descrevemos como trabalhar com o Maven para criar aplicativos J2EE. O Maven fornece uma estrutura extensível usando um mecanismo de plug-in.

Esta seção mostra como criar um plug-in Maven que procura ou cria uma máquina virtual na nuvem usando a API IBM SmartCloud:

1. O plug-in primeiro tenta consultar a instância da máquina virtual.
2. Se for encontrada, pode ser usada para fornecer o aplicativo J2EE.
3. Caso contrário, uma nova máquina virtual é criada.

Para começar, gere um projeto de plug-in do Maven de amostra usando a linha de comando:

>mvn archetype:generate -DarchetypeArtifactId=maven-archetype-mojo 
 -DgroupId=com.ibm.cloud.enterprise.example 
 -DartifactId=sce-maven-plugin -DinteractiveMode=false

Isso cria uma árvore de diretório do projeto de plug-in com o tipo MOJO (Maven Old Java Object).

Importe o projeto para o ambiente de desenvolvimento integrado e adicione as bibliotecas de plug-in e núcleo do Maven ao seu caminho de criação do ambiente de desenvolvimento integrado. Os plug-ins Maven implementam a interface Mojo , normalmente estendendo a classe AbstractMojo . Adicione o código de origem para a classe SCEMojo :

package com.ibm.cloud.enterprise.example;

import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;

import com.ibm.cloud.api.rest.client.DeveloperCloud;
import com.ibm.cloud.api.rest.client.DeveloperCloudClient;
import com.ibm.cloud.api.rest.client.bean.Address;
import com.ibm.cloud.api.rest.client.bean.Instance;
import com.ibm.cloud.api.rest.client.bean.Volume;
import com.ibm.cloud.api.rest.client.exception.*;

/**
 * @goal create_instance
 */
public class SCEMojo extends AbstractMojo {

     private DeveloperCloudClient client = DeveloperCloud.getClient();
     private Log log = getLog();

     /**
     * The user name for the cloud account
     * @parameter expression="${create_instance.user_name}"
     */
    private String user_name;

     /**
     * The password for the cloud account
     * @parameter expression="${create_instance.password}"
     */
    private String password;

     /**
     * The name of the server to lookup or create
     * @parameter expression="${create_instance.name}" default-value="app_server"
     */
    private String name;

     /**
     * The data center to create the server in
     * @parameter expression="${create_instance.data_center}"
     */
    private String data_center;

    /**
     * The image ID to create the server with
     * @parameter expression="${create_instance.image_id}"
     */
    private String image_id;

    /**
     * The name of the SSH key to create the server with
     * @parameter expression="${create_instance.key_name}"
     */
    private String key_name;

    /**
     * The name of the WebSphere administrative user
     * @parameter expression="${create_instance.was_admin_user}"
     */
    private String was_admin_user;

     /**
     * The name of the WebSphere administrative user password
     * @parameter expression="${create_instance.was_admin_password}"
     */
    private String was_admin_password;

}

O código já tem as importações para os métodos que serão adicionados abaixo. O JavaDoc no nível da classe tem uma identificação de @goal . Isso é obrigatório e indica o objetivo da criação, que é create_instance. Os campos privados user_name, password, name, data_center, image_id, key_name, was_admin_user e was_admin_password são parâmetros passados por usuários do plug-in. Os parâmetros são:

• user_name:O nome de usuário para a conta de nuvem
• password:A senha para a conta de nuvem
• nome:O nome do servidor para consulta ou criação, valor padrão="app_server"
• data_center:O datacenter no qual criar o servidor
• image_id:O ID da imagem com o qual criar o servidor
• key_name:O nome da chave SSH com o qual criar o servidor
• was_admin_user:O nome do usuário administrativo do WebSphere
• was_admin_password:O nome do usuário administrativo e senha do WebSphere

Classes implementando a interface Mojo devem implementar o método execute . Inclua o objeto execute :

public void execute() throws MojoExecutionException {
     try {
              log.info("Logging onto cloud with user name " + user_name);
              client.setRemoteCredentials(user_name, password);
              log.info("Looking for a server with name " + name);
          List<Instance> instances = client.describeInstances();
              log.info("Found " + instances.size() + " instances");
              boolean found = false;
              for (Instance instance: instances) {
                   if ((instance.getStatus() == Instance.Status.ACTIVE) &&
                        instance.getName().equals(name)) {
                        log.info("Found a server with name " + name);
                        found = true;
                   }
              }
              if (!found) {
                   log.info("No server with name " + name + " found");
                   createInstance();
              }
     } catch (Exception e) {
              log.warn(e);
          throw new MojoExecutionException(e.getMessage());
     }
}

O método primeiro define as credenciais do usuário, então recupera uma lista de máquinas virtuais de propriedade do usuário. Ele itera sobre a lista de máquinas virtuais procurando uma instância ativa com o mesmo nome que o parâmetro fornecido pelo usuário.

Se uma máquina virtual for encontrada, está concluído. Caso contrário, é criada uma máquina virtual com o método createInstance() adicionando esse método à classe SCEMojo :

private void createInstance() throws InsufficientResourcesException,
              InvalidConfigurationException, PaymentRequiredException,
              UnauthorizedUserException, UnknownErrorException, IOException {
     Address address = null;
     Volume volume = null;
     Address[] secondaryAddresses = new Address[0];
     Map parameters = new HashMap<String,Object>();
     parameters.put("WASAdminUser", was_admin_user);
     parameters.put("WASAdminPassword", was_admin_password);
     List<Instance> newInstances = client.createInstance(
               name, // Nome da instância
               data_center, // ID do datacenter
               image_id, // ID da imagem
               "COP32.1/2048/60", // Tipo de instância
               key_name, // Chave
               address, // Endereço
               volume, // Volume
               parameters, // Opções
               null, // ID VLAN
               secondaryAddresses, // Endereços IP secundários
               true); // Minimum ephemeral
     Instance instance = newInstances.get(0);
     log.info("ID: " + instance.getID());
}

O método cria a máquina virtual com os parâmetros fornecidos pelo usuário e grava o ID da instância ao log.

como mostrado na Listagem 17, agora crie um arquivo pom.xml para o plug-in:

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd" 
 xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.ibm.cloud.enterprise</groupId>
  <artifactId>sce-maven-plugin</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>maven-plugin</packaging>
  <name>sce-maven-plugin Maven Mojo</name>
  <url>http://ibm.com/cloud/enterprise</url>
  <dependencies>
    <dependency>
      <groupId>org.apache.maven</groupId>
      <artifactId>maven-plugin-api</artifactId>
      <version>2.0</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>commons-httpclient</groupId>
      <artifactId>commons-httpclient</artifactId>
      <version>3.1</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.1</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>commons-codec</groupId>
      <artifactId>commons-codec</artifactId>
      <version>1.3</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>commons-lang</groupId>
      <artifactId>commons-lang</artifactId>
      <version>2.3</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>com.ibm.cloud.enterprise</groupId>
      <artifactId>DeveloperCloud_API_Client</artifactId>
      <version>1.4.1</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
</project>

O arquivo pom.xml usa um tipo de pacote maven-plugin . Ele define uma dependência maven-plugin-api e dependências da API IBM SmartCloud Enterprise Java e suas bibliotecas, Apache HTTP Client, Commons, Logging, Codec e Lang dependentes. As bibliotecas do Apache podem ser transferidas por download automaticamente pelo Maven a partir do repositório central do Maven.

Faça o download e instale a biblioteca de API SmartCloud no seu repositório local:

mvn install:install-file -Dfile=/opt/sce/DeveloperCloud_API_Client_1.4.1.jar 
 -DgroupId=com.ibm.cloud.enterprise 
 -DartifactId=DeveloperCloud_API_Client 
 -Dversion=1.4.1 -Dpackaging=jar

Agora, deve-se ajustar o parâmetro do arquivo para que seja consistente com o ambiente local.

A seguir, construa e instale o plug-in no repositório local:

>mvn package
>mvn install

Agora é possível usar o plug-in para um projeto. Vamos gerar o aplicativo da nuvem de projeto com o comando generate do Maven:

mvn archetype:generate -DgroupId=com.ibm.cloud.enterprise 
 -DartifactId=cloud-app 
 -DarchetypeArtifactId=maven-archetype-quickstart 
 -DinteractiveMode=false

Importe o novo projeto para o seu ambiente de desenvolvimento integrado. Modifique o pom.xml gerado para adicionar uma configuração de plug-in e dependência:

<?xml version="1.0"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
 http://maven.apache.org/xsd/maven-4.0.0.xsd" 
 xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.ibm.cloud.enterprise</groupId>
  <artifactId>cloud-app</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>cloud-app</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>com.ibm.cloud.enterprise</groupId>
      <artifactId>sce-maven-plugin</artifactId>
      <version>1.0-SNAPSHOT</version>
      <scope>compile</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>com.ibm.cloud.enterprise</groupId>
        <artifactId>sce-maven-plugin</artifactId>
        <version>1.0-SNAPSHOT</version>
        <configuration>
          <user_name>a.user@example.com</user_name>
          <password>****</password>
          <name>was</name>
          <data_center>101</data_center>
          <image_id>20015399</image_id>
          <key_name>july26</key_name>
          <was_admin_user>wasadmin</was_admin_user>
          <was_admin_password>***</was_admin_password>
        </configuration>
        <executions>
          <execution>
            <phase>compile</phase>
            <goals>
              <goal>create_instance</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

Observe o uso dos parâmetros na seção configuration .

Agora você está pronto para testar o plug-in. Primeiro verifique com uma nova instância e uma instância existente; chame o plug-in com o objetivo do Maven mostrada abaixo.

>mvn com.ibm.cloud.enterprise:sce-maven-plugin:1.0-SNAPSHOT:create_instance

Se você ainda não tem uma máquina virtual com o nome fornecido, deve ver uma saída como esta:

[info] Logging onto cloud with user name a.user@example.com
[info] Looking for a server with name was
[info] Found 4 instances
[info] No server with name was found
[info] ID: 112332
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] 
...

Se você já tem uma máquina virtual com o nome fornecido, deve ver uma saída como esta:

...
[INFO] --- sce-maven-plugin:1.0-SNAPSHOT:create_instance (default-cli) @ cloud-a
pp ---
[info] Logging onto cloud with user name aamies@cn.ibm.com
[info] Looking for a server with name was
[info] Found 5 instances
[info] Found a server with name was
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ----------------------------------------------------------------------
...

Lembre-se de que se você executou recentemente o comando na Listagem 22 para criar um servidor, ele leva algum tempo para ser criado.

Até o momento neste artigo, essa foi uma boa maneira de ver como a nuvem pode se enquadrar no ciclo de vida de desenvolvimento e implementação, mas há mais algumas etapas para tornar esse processo ainda mais útil no ciclo de vida.

Demonstramos que leva algum tempo para criar um servidor. É preciso que o mecanismo de pesquisa espere isso ser concluído; entretanto, há um desafio adicional aqui, que é determinar quando o servidor de aplicativos em si foi ativado, o que será apenas após o fornecimento da máquina virtual e o sistema operacional ter iniciado. É possível usar as APIs wsadmin do WebSphere para isso. Quando houver um servidor ativo com o servidor de aplicativos executando, é possível implementar o nosso aplicativo J2EE nele. Quando tiver concluído o servidor WebSphere, é possível excluí-lo. Pode-se desejar adicionar isso à fase de limpeza do ciclo de vida ou em outro ponto.

Voltar para parte superior

Próximas etapas

Algumas outras tarefas que você pode desejar realizar ou incluir:

• Criar um repositório Maven privado na IBM Cloud. Essa é uma tarefa importante, porque uma empresa normalmente deseja manter seus softwares não lançados, proprietários ou comprados comercialmente separados do software livre já lançado armazenado em repositórios públicos. Isso simplificará o compartilhamento de software dentro da empresa e com parceiros de negócio e o manterá isolado do público em geral.
• Criar um modelo de projeto de API na nuvem. Um modelo de projeto é útil para simplificar a criação de vários projetos na nuvem, padronizar melhores práticas e eliminar a repetição.

Servidores de aplicativos J2EE têm vários recursos que ajudam a alcançar os objetivos de desempenho e disponibilidade. Um dos principais recursos é a habilidade de colocar servidores de aplicativos em cluster para carga distribuída. Um cluster é um grupo de nós de servidor de aplicativos ou servidores de aplicativos individuais que funciona como um grupo para balancear a carga de trabalho. Em computação em nuvem, existe a oportunidade de criar máquinas virtuais dinamicamente, e elas podem agir como nós no cluster.

O WebSphere Application Server é uma plataforma J2EE particularmente adequada para gerenciar clusters em grande escala. Todas as etapas que podem ser realizadas no console administrativo do WebSphere podem ser redigidas com comandos e ferramenta wsadmin, incluindo programas Java com os scripts Java Management eXtensions (JMX) e Jython. É possível combinar esse conhecimento do modelo de implementação de rede do WebSphere com o conhecimento da criação e personalização de imagens e o que você já aprendeu sobre a API REST do IBM SmartCloud Enterprise para automatizar o fornecimento de elementos de um cluster do WebSphere. Isso é feito da seguinte maneira:

1. Inicie com uma imagem do WebSphere Application Server, então personalize o perfil com a Profile Management Tool e o servidor de aplicativos com o console administrativo.
2. Salve a máquina virtual em uma instância com a interface com o usuário do IBM Cloud ou API REST.
3. Use a API REST da IBM Cloud para fornecer novas máquinas virtuais.
4. Use a ferramenta wsadmin para unir as máquinas virtuais ao cluster e sincronizar a implementação do aplicativo através dos nós, incluindo a implementação do seu aplicativo J2EE.

Voltar para parte superior

Conclusão

Este artigo apresentou uma amostra do projeto J2EE para você usar na IBM Cloud; uma imagem do WebSphere Application Server que fornece um ambiente J2EE sem precisar instalar nenhum software adicional. Descreveu as etapas para configurar o Apache Maven no seu ambiente e começar com a automação de criação. Descrevemos como trabalhar com o Maven para construir aplicativos J2EE. Foi mostrado como criar um plug-in Maven que procura ou cria uma máquina virtual na nuvem usando a API IBM SmartCloud. E, como um bônus, apresentamos o caminho para algumas outras tarefas similares que você pode desejar realizar, incluindo como criar um repositório Maven privado na IBM Cloud e como construir um modelo de projeto da API na nuvem.

O único ponto que faltou você fazer é experimentar.

Recursos

Aprender

• Bem-vindo ao Apache Maven, uma ferramenta de compreensão e gerenciamento de projeto de software baseada no conceito de project object model (POM) — ela pode gerenciar a criação, o relatório e a documentação de um projeto a partir de uma informação central.
  
  
• O developerWorks possui uma boa biblioteca de recursos do Maven:
  • Introduction to Apache Maven 2
  • Exploiting Maven in Eclipse
  • 5 Coisas que Você Não Sabia Sobre... Apache Maven
  • When Maven encounters Eclipse
  No developerWorks, procure os recursos do desenvolvedor de software livre e Java para mais instâncias do Maven (dica: Artigos do Apache Geronimo estão muito relacionados com o Maven).
  
• Para saber mais sobre como realizar tarefas na nuvem IBM, visite estes recursos:
  • Faça upload e download de arquivos a partir de uma instância do Windows.
  • Instalar o servidor da web IIS no Windows 2008 R2.
  • Crie uma instância da nuvem IBM com a linha de comando do Linux.
  • Crie uma instância da nuvem IBM com a linha de comando do Windows.
  • Estenda a sua rede corporativa com a nuvem IBM.
  • Aplicativos de alta disponibilidade na nuvem IBM.
  • Parametrize imagens de nuvem para instâncias customizadas dinamicamente.
  • Abordagens focadas no Windows para fornecimento na nuvem IBM.
  • Implemente produtos usando o serviço de implementação rápida.
  • Integre a política de autenticação usando um proxy.
  • Configure o Linux Logical Volume Manager.
  • Implementar uma topologia complexa usando uma ferramenta de utilitário de implementação.
  • Forneça e configure uma instância que envolve uma VLAN pública e privada.
  • Proteger o acesso à IBM Cloud para dispositivos Android.
  
  
• Nos recursos para desenvolvedores de nuvem do developerWorks, descubra e compartilhe o conhecimento e a experiência dos desenvolvedores de aplicativos e serviços que estão desenvolvendo os seus projetos de implementação de nuvem.
  
  
• Descubra como acessar o IBM SmartCloud Enterprise.
  
  

Obter produtos e tecnologias

• Inscreva-se para uma avaliação gratuita do IBM SmartCloud Enterprise. Tempo limitado. O último dia para se inscrever para essa oferta é 28 de outubro de 2011 e o período de avaliação termina no dia 11 de novembro de 2011. Visite o site do IBM Cloud para obter mais ofertas , caso essa tenha expirado.
  
  
• Consulte as imagens do produto disponíveis para IBM SmartCloud Enterprise.
  
  

Discutir

• Participe de um grupo sobre computação em nuvem no developerWorks.
  
  
• Leia todos os ótimos blogs sobre nuvem no developerWorks.
  
  
• Participe da comunidade do developerWorks, uma rede profissional e conjunto de ferramentas comunitárias para conectar, compartilhar e colaborar.
  
  

Sobre os autores

Alex Amies é engenheiro de software senior no Laboratório de Desenvolvimento IBM GTS no laboratório de desenvolvimento da China. Ele é atualmente arquiteto e trabalha no design do Desenvolvimento e Teste de Negócios Inteligentes IBM na Nuvem IBM. Anteriormente, ele atuou como arquiteto e desenvolvedor de produtos de nuvem e de segurança em outros grupos na IBM.

Pan Xia Zou é engenheiro de software contratado na IBM e trabalha como arquiteto de automação de criação e implementação para o IBM SmartCloud Enterprise.

Yi Shuai Wang é arquiteto consultivo da IBM e desenvolvedor líder para o desenvolvimento de serviços de suporte de negócios do IBM SmartCloud Enterprise.

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Projeto J2EE de amostra
• Automação de criação com Maven
• Plug-in Maven para automação de criação e implementação de servidor
• Próximas etapas
• Conclusão
• Recursos
• Sobre os autores
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais