Información:
Comparto esta guia en la cual explico las configuraciones a realizar, el entorno de HCP y ejemplos prácticos que se aplican para cualquier desarrollo que queramos hacer en el futuro.
CONFIGURACION INICIAL CON HCP Tools Java
Install Java Tools for Eclipse: https://help.hana.ondemand.com/help/frameset.htm?e815ca4cbb5710148376c549fd74c0db.html
1) Install New Software para cada version correspondiente de eclipse: Se recomienda utilizar Eclipse en su ultima version.
2) De la lista desplegada, seleccionar los de la siguiente lista:
3) Quedando de la siguiente forma las utilidades en Eclipse: Es muy recomendable utilizar una version de eclipse luna que no tenga otros plugins previamente instalados.
Una vez instalados los plugins, es necesario seguir los siguientes pasos.
4) INSTALL SAP HANA CLOUD PLATFORM SDK: https://tools.hana.ondemand.com/#cloud
Una vez se ingresa a la pagina mencionada, se observa las opciones de descarga para el SDK.
Proceso de instalacion:
Despues de descargar el Sap Hana Cloud Platform SDK, seguir los siguientes pasos:
Se procede a configurar el SDK de HCP:
Ahora es necesario configurar el HOST. Para esto escoger el servidor de pruebas que usted utilice para HCP (Hana Cloud Platform).
En este caso utilizo el de Europa:
Después de ingresar los valores dar clic en validar para observar que todo este correcto:
El nombre de usuario se puede obtener desde el HCP,
Ejemplo:
5) Configuration del Runtime Environment
Seguir los siguientes pasos:
Clicen "Next", y aparecera el siguiente formulario:
Como se observa, la configuracion de el Servidor para HCP quedo lista:
6) INSTALL SAP JVM in Eclipse IDE (Opcional pero es recomendado instalarlo en caso de no tenerlo)
Link descarga: https://tools.hana.ondemand.com/#cloud
Escoger el sistema operativo correspondiente:
Preferiblemente para el SAP JVM la version 7.X o superior.
Proceso de instalación:
7) Configuración Up the Console Client SDK
Lo primero que se debe hacer es ubicarse por medio de consola Mac o Windows la ruta del SDK instalado. Una vez en ahi, buscar la carpeta llamada "Tools", dentro de esta se encuentran los programas ejecutables para cada sistema operativo, siendo la extension .bat para Windows y la extension .sh para Mac.
Ahora se realiza la configuracion basica de los Proxy de conexion:
Para mas información sobre las configuraciones leer el archivo "readme.txt".
Creación de la primera aplicacion
Crear un proyecto "Dynamic Web Project"
Aparece lo siguiente:
Clic en siguiente, siguiente y se pone lo siguiente:
Clic en finalizar.
A continuación se procede a crear un nuevo Servlet para el proyecto.
Se ingresan los siguientes datos, para dar nombre al Servlet y configuracion:
Clic en "Next", y se edita la ruta "URL Mappings"
Clic en "Finish", y se observa lo siguiente:
A continuación para el ejemplo, se agrega la siguiente linea de código y se ejecuta el servidor:
El resultado de la ejecucion se observa a continuacion:
😎 Deploy aplicacion a SAP HCP (SAP HANA CLOUD PLATFORM)
Para subir la aplicacion al HCP es necesario realizar los siguientes pasos:
Clic derecho en el proyecto -> Run As -> Run on Server
Aparecera la siguiente pantalla:
A continuación pide la clave del usuario previamente configurado en un numeral anterior:
Después de esperar unos minutos al realizar el Deploy, ingresar al HCP, para observar la nueva aplicacion:
Al dar clic en la aplicacion, se observa las configuraciones y propiedades de la aplicacion:
Se observa la ejecución de la aplicacion correctamente:
COMENZAR CON SAP HANA TOOLS
1) Instalar el plugins, https://tools.hana.ondemand.com/mars
Una vez instalados, se empezara a configurar lo necesario para realizar el primer ejemplo con una Base de datos Hana.
Ingresar al HCP, y realizar lo siguiente:
El resultado esperado es el siguiente:
A continuación, se resumen los pasos:
2) Conectar a una base de datos HANA en Eclipse IDE
A continuación se detallan los pasos a seguir:
Seleccionar SAP HANA ADMINISTRATION CONSOLE y pulsar Ok.
Se procede a agregar un nuevo Sistema Cloud:
A continuación ingresar la clave del HCP:
Se muestra a continuación los esquemas disponibles. Seleccionar el creado previamente "ejemplo1".
Si todo lo anterior fue correcto, se deberá mostrar en el entorno de trabajo lo siguiente:
3) Crear un Subpackage
A continuación se describen los pasos a seguir.
Cambiar de perspectiva:
Ahora se selecciona el siguiente nodo del esquema base de datos:
Una vez seleccionado, clic derecho crear nuevo paquete:
Al dar clic en "Package", se muestra lo siguiente:
Se muestra el paquete creado correctamente.
4) Crear un repositorio WorkSpace.
A continuación se muestran los pasos a seguir detalladamente.
Crear repositorio:
Una vez creado el repositorio, se mostrara la ruta en la cual fue alojado:
5) Crear un proyecto HANA XS
Nota: XS es JavaScript del lado del servidor extension xsjs
A continuación se detallan los pasos a seguir:
Ingresar el nombre de la aplicacion y dar clic en "Next".
Seleccionar el repositorio previamente creado:
Una vez finalice, se creara la aplicacion XS como se muestra en la siguiente imagen:
6) Creando la aplicacion con Descriptor y roles:
Application descriptor
El archivo a crear posee como extension .xsapp
Application access file
Tambien se creara un archivo con extension .xsaccess y el contenido de este archivo sera:
{ "exposed" : true, "default_file": "hola.xsjs" }
Application privileges file
Crear otro archivo con nombre extension .xsprivileges Con el siguiente contenido:
{ "privileges" :
[ { "name" : "Basic", "description" : "Basic usage privilege" } ]}
Role:
Crear un archivo con el nombre model_access.hdbrole el contenido sera el siguiente:
role <package name>::model_access {
application privilege: <package name>::Basic;
}
7) Creando un archivo JavaScript
Código:
$.response.contentType = "text/html"; var output = "Hello, " + $.session.getUsername() + " <br><br>"; var conn = $.db.getConnection(); var pstmt = conn.prepareStatement( "SELECT CURRENT_USER FROM DUMMY" ); var rs = pstmt.executeQuery(); if (!rs.next()) { $.response.setBody( "Failed to retrieve data" ); $.response.status = $.net.http.INTERNAL_SERVER_ERROR; } else { output = output + "This is the response from my SQL. The current user is: " + rs.getString(1); } rs.close(); pstmt.close(); conn.close(); $.response.setBody(output);
Ejecutar el proyecto:
Para subir el proyecto y verificar que no existen errores, es necesario realizar lo siguiente:
Después de activar correctamente la aplicacion, se procede a ingresar al HCP, he ingresar a la sección HANA XS APPLICATIONS,
El resultado de la aplicacion es el siguiente:
INSTALAR SAP HANA CLOUD CONNECTOR
https://tools.hana.ondemand.com/#cloud
SAP Hana Cloud Connector sirve de enlace entre las aplicaciones bajo demanda en SAP HANA Cloud Platform y sistemas en las instalaciones existentes. Combina una fácil configuración con una configuración clara de los sistemas que están expuestos a SAP HANA Cloud Platform. Además, puede controlar los recursos disponibles para las aplicaciones en la nube en esos sistemas. Por lo tanto, puede beneficiarse de sus activos existentes sin exponer todo el paisaje interno.
Una vez descargado el archivo comprimido, se procede a extraerlo. A continuación posicionándose en la carpeta extraída
ejecutar al archivo .SH con nombre .go.sh
Se ingresa en el navegador la ruta: https://localhost:8443 y mostrara lo siguiente:
Para nombre de usuario ingrese Administrator y para la clave manage (case sensitive).
Después de ingresar, aparece lo siguiente, por el momento escoger la opción Master.
A continuación, el sistema solicita el cambio de clave:
Configuración inicial con el hanatrial:
Si la configuración se realizo correctamente deberá aparecer la siguiente pantalla con toda la información de conectividad con el hanatrial:
Configuración del proxy. NOTA: Para este caso no fue necesario
Agregar persistencia con JDBC (Java Web SDK)
Este tutorial paso a paso se muestra cómo se puede utilizar JDBC para guardar los datos en una sencilla aplicación web Java EE que maneja una lista de las personas.
1) Creación de un Dynamic Web Proyect
Ahora se procede a crear un nuevo Servlet:
Configuración del Servlet a crear:
A continuación se observa el Servlet creado correctamente:
2) Se procede a crear una nueva clase para el Servlet creado.
Cuando se crea la clase correctamente se observa lo siguiente:
Se procede a pegar el siguiente codigo en la clase. Este codigo declara las variables y metodos basicos para el programa.
package com.sap.cloud.sample.persistence; public class Person { private String id; private String firstName; private String lastName; public String getId() { return id; } public void setId(String newId) { this.id = newId; } public String getFirstName() { return this.firstName; } public void setFirstName(String newFirstName) { this.firstName = newFirstName; } public String getLastName() { return this.lastName; } public void setLastName(String newLastName) { this.lastName = newLastName; } }La clase queda de la siguiente forma:
3) Crear la clase PersonDAO
Para esta clase, se necesita el siguiente codigo Java:
import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; import java.util.UUID; import javax.sql.DataSource; /** * Data access object encapsulating all JDBC operations for a person. */ public class PersonDAO { private DataSource dataSource; /** * Create new data access object with data source. */ public PersonDAO(DataSource newDataSource) throws SQLException { setDataSource(newDataSource); } /** * Get data source which is used for the database operations. */ public DataSource getDataSource() { return dataSource; } /** * Set data source to be used for the database operations. */ public void setDataSource(DataSource newDataSource) throws SQLException { this.dataSource = newDataSource; checkTable(); } /** * Add a person to the table. */ public void addPerson(Person person) throws SQLException { Connection connection = dataSource.getConnection(); try { PreparedStatement pstmt = connection .prepareStatement("INSERT INTO PERSONS (ID, FIRSTNAME, LASTNAME) VALUES (?, ?, ?)"); pstmt.setString(1, UUID.randomUUID().toString()); pstmt.setString(2, person.getFirstName()); pstmt.setString(3, person.getLastName()); pstmt.executeUpdate(); } finally { if (connection != null) { connection.close(); } } } /** * Get all persons from the table. */ public List<Person> selectAllPersons() throws SQLException { Connection connection = dataSource.getConnection(); try { PreparedStatement pstmt = connection .prepareStatement("SELECT ID, FIRSTNAME, LASTNAME FROM PERSONS"); ResultSet rs = pstmt.executeQuery(); ArrayList<Person> list = new ArrayList<Person>(); while (rs.next()) { Person p = new Person(); p.setId(rs.getString(1)); p.setFirstName(rs.getString(2)); p.setLastName(rs.getString(3)); list.add(p); } return list; } finally { if (connection != null) { connection.close(); } } } /** * Check if the person table already exists and create it if not. */ private void checkTable() throws SQLException { Connection connection = null; try { connection = dataSource.getConnection(); if (!existsTable(connection)) { createTable(connection); } } finally { if (connection != null) { connection.close(); } } } /** * Check if the person table already exists. */ private boolean existsTable(Connection conn) throws SQLException { DatabaseMetaData meta = conn.getMetaData(); ResultSet rs = meta.getTables(null, null, "PERSONS", null); while (rs.next()) { String name = rs.getString("TABLE_NAME"); if (name.equals("PERSONS")) { return true; } } return false; } /** * Create the person table. */ private void createTable(Connection connection) throws SQLException { PreparedStatement pstmt = connection .prepareStatement("CREATE TABLE PERSONS " + "(ID VARCHAR(255) PRIMARY KEY, " + "FIRSTNAME VARCHAR (255)," + "LASTNAME VARCHAR (255))"); pstmt.executeUpdate(); } }El resultado seria algo como esto:
4) Preparando la aplicacion web para JDBC
Primero se importaran algunas librerías necesarias de Sap Hana Cloud platform SDK
A continuación buscamos el directorio local en el cual fue alojado el Sap Hana Cloud SDK
Para este caso se debe tener descargado el SDK que se muestra a continuación : https://tools.hana.ondemand.com/#cloud
Con esto ya podemos seguir con la importacion de la libreria com.sap.security.core.server.csi_1.x.y.jar
ubicada en la ruta repository/plugins dentro del directorio raiz del SDK.
Después de dar clic en finalizar se observa la libreria importada correctamente:
Adaptando Java build path:
Después de actualizar el Build Path se procede a agregar las referencias y descripción de los recursos en el web.xml
Agregar las siguientes lineas al archivo:
<resource-ref> <res-ref-name>jdbc/DefaultDB</res-ref-name> <res-type>javax.sql.DataSource</res-type> </resource-ref>
<!--Opcional-->
<servlet-mapping> <servlet-name>PersistenceWithJDBCServlet</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping>
El resultado seria el siguiente:
5) Extendiendo servlet para usar persistencia
Editamos el archivo que se muestra en la siguiente imagen:
Agregamos el siguiente código:
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.sap.security.core.server.csi.IXSSEncoder;
import com.sap.security.core.server.csi.XSSEncoder;
/**
* Servlet implementing a simple JDBC based persistence sample application for
* SAP HANA Cloud Platform.
*/
public class PersistenceWithJDBCServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
private static final Logger LOGGER = LoggerFactory
.getLogger(PersistenceWithJDBCServlet.class);
private PersonDAO personDAO;
/** {@inheritDoc} */
@Override
public void init() throws ServletException {
try {
InitialContext ctx = new InitialContext();
DataSource ds = (DataSource) ctx
.lookup("java:comp/env/jdbc/DefaultDB");
personDAO = new PersonDAO(ds);
} catch (SQLException e) {
throw new ServletException(e);
} catch (NamingException e) {
throw new ServletException(e);
}
}
/** {@inheritDoc} */
@Override
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
response.getWriter().println("<p>Persistence with JDBC!</p>");
try {
appendPersonTable(response);
appendAddForm(response);
} catch (Exception e) {
response.getWriter().println(
"Persistence operation failed with reason: "
+ e.getMessage());
LOGGER.error("Persistence operation failed", e);
}
}
/** {@inheritDoc} */
@Override
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException {
try {
doAdd(request);
doGet(request, response);
} catch (Exception e) {
response.getWriter().println(
"Persistence operation failed with reason: "
+ e.getMessage());
LOGGER.error("Persistence operation failed", e);
}
}
private void appendPersonTable(HttpServletResponse response)
throws SQLException, IOException {
// Append table that lists all persons
List<Person> resultList = personDAO.selectAllPersons();
response.getWriter().println(
"<p><table border=\"1\"><tr><th colspan=\"3\">"
+ (resultList.isEmpty() ? "" : resultList.size() + " ")
+ "Entries in the Database</th></tr>");
if (resultList.isEmpty()) {
response.getWriter().println(
"<tr><td colspan=\"3\">Database is empty</td></tr>");
} else {
response.getWriter()
.println(
"<tr><th>First name</th><th>Last name</th><th>Id</th></tr>");
}
IXSSEncoder xssEncoder = XSSEncoder.getInstance();
for (Person p : resultList) {
response.getWriter().println(
"<tr><td>" + xssEncoder.encodeHTML(p.getFirstName())
+ "</td><td>"
+ xssEncoder.encodeHTML(p.getLastName())
+ "</td><td>" + p.getId() + "</td></tr>");
}
response.getWriter().println("</table></p>");
}
private void appendAddForm(HttpServletResponse response) throws IOException {
// Append form through which new persons can be added
response.getWriter()
.println(
"<p><form action=\"\" method=\"post\">"
+ "First name:<input type=\"text\" name=\"FirstName\">"
+ " Last name:<input type=\"text\" name=\"LastName\">"
+ " <input type=\"submit\" value=\"Add Person\">"
+ "</form></p>");
}
private void doAdd(HttpServletRequest request) throws ServletException,
IOException, SQLException {
// Extract name of person to be added from request
String firstName = request.getParameter("FirstName");
String lastName = request.getParameter("LastName");
// Add person if name is not null/empty
if (firstName != null && lastName != null
&& !firstName.trim().isEmpty() && !lastName.trim().isEmpty()) {
Person person = new Person();
person.setFirstName(firstName.trim());
person.setLastName(lastName.trim());
personDAO.addPerson(person);
}
}
}
A continuacion se muestra un ejemplo mas completo en el cual tendra como objetivo, creacion de tablas, insert, select a base de datos Hana desde una aplicacion Java con JPA.
Agregar administrador de contenido Persistente con JPA (Java EE 6 Web Profile SDK)
Esquema:
Prerequisitos:
Para continuar con la creación de aplicaciones Java con JPA es necesario lo siguiente:
1) Link de descarga: https://tools.hana.ondemand.com/#cloud
2) Descargar EclipseLink JAR file (requiere eclipselink.jar) http://www.eclipse.org/eclipselink/downloads
version 2.5.x
3) Crear un Dynamic web proyect en eclipse 
File 
New Dynamic Web Project (En pasos anteriores se explica el proceso) para este ejemplo el nombre del proyecto sera pesistence-with-ejb
Después clic en siguiente, siguiente y aparecera la siguiente ventana en la cual se seleccionara EclipceLink
Clic en siguiente y marcar el CheckBox:
Por ultimo clic en finalizar.
4) Con esto ya podemos crear aplicaciones persistentes con JPA. A continuación se creara un Servlet nuevo File New Servlet 
Ahora es necesario crea una nueva clase llamada Person que tiene el siguiente código:
import javax.persistence.Basic; import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.NamedQuery; import javax.persistence.Table; /** * Class holding information on a person. */ @Entity @Table(name = "T_PERSON") @NamedQuery(name = "AllPersons", query = "select p from Person p") public class Person { @Id @GeneratedValue private Long id; @Basic private String firstName; @Basic private String lastName; public long getId() { return id; } public void setId(long newId) { this.id = newId; } public String getFirstName() { return this.firstName; } public void setFirstName(String newFirstName) { this.firstName = newFirstName; } public String getLastName() { return this.lastName; } public void setLastName(String newLastName) { this.lastName = newLastName; } }
5) Ahora es necesario configurar el archivo XML con nombre persistence.xml
El detalle de los pasos anteriores es el siguiente:
5.1) Abrir el editor XML adecuado para editar el archivo:
5.2) Verificar la siguiente información en el Tab General:
5.3) Verificar la siguiente información en el Tab Options:
5.4) Verificar la información del tab Connection:
6) Crear EJB Session Bean:
En este archivo se encuentran las operaciones a realizar sobre la base de datos. Para crearlo seguir los siguientes pasos:
File New Other EJB Session Bean (EJB 3.x)
Al final se debe tener el proyecto lo siguiente:
El código que tendra EJB PersonBean.java es el siguiente:
import java.util.List; import javax.ejb.LocalBean; import javax.ejb.Stateless; import javax.persistence.EntityManager; import javax.persistence.PersistenceContext; /** * Session Bean implementation class PersonBean */ @Stateless @LocalBean public class PersonBean { @PersistenceContext private EntityManager em; public List<Person> getAllPersons() { return em.createNamedQuery("AllPersons").getResultList(); } public void addPerson(Person person) { em.persist(person); em.flush(); } }
7) Preparando la aplicacion web para JPA
Es necesario importar la libreria com.sap.security.core.server.csi_1.x.y.jar que se encuentra en el SDK Java EE 6 web.
Para esto seguir los siguientes pasos:
En la ventana que aparece, clic en Browser, para buscar la siguiente ruta:
Una vez se escoge la ruta, aparece lo siguiente:
Ahora se importara la libreria eclipselink.jar
Al final la carpeta Lib deberá de contener las siguientes librerías:
😎 Extendiendo un Sevlet usando Persistencia.
En el archivo PersistenceEJBServlet.java agregar el siguiente código
import java.io.IOException; import java.sql.SQLException; import java.util.List; import javax.ejb.EJB; import javax.servlet.ServletException; import javax.servlet.annotation.WebServlet; import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.sap.security.core.server.csi.IXSSEncoder; import com.sap.security.core.server.csi.XSSEncoder; /** * Servlet implementation class PersistenceEJBServlet */ @WebServlet("/") public class PersistenceEJBServlet extends HttpServlet { private static final long serialVersionUID = 1L; private static final Logger LOGGER = LoggerFactory .getLogger(PersistenceEJBServlet.class); @EJB PersonBean personBean; /** {@inheritDoc} */ @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.getWriter().println("<p>Persistence with JPA!</p>"); try { appendPersonTable(response); appendAddForm(response); } catch (Exception e) { response.getWriter().println( "Persistence operation failed with reason: " + e.getMessage()); LOGGER.error("Persistence operation failed", e); } } /** {@inheritDoc} */ @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { doAdd(request); doGet(request, response); } catch (Exception e) { response.getWriter().println( "Persistence operation failed with reason: " + e.getMessage()); LOGGER.error("Persistence operation failed", e); } } private void appendPersonTable(HttpServletResponse response) throws SQLException, IOException { // Append table that lists all persons List<Person> resultList = personBean.getAllPersons(); response.getWriter().println( "<p><table border=\"1\"><tr><th colspan=\"3\">" + (resultList.isEmpty() ? "" : resultList.size() + " ") + "Entries in the Database</th></tr>"); if (resultList.isEmpty()) { response.getWriter().println( "<tr><td colspan=\"3\">Database is empty</td></tr>"); } else { response.getWriter() .println( "<tr><th>First name</th><th>Last name</th><th>Id</th></tr>"); } IXSSEncoder xssEncoder = XSSEncoder.getInstance(); for (Person p : resultList) { response.getWriter().println( "<tr><td>" + xssEncoder.encodeHTML(p.getFirstName()) + "</td><td>" + xssEncoder.encodeHTML(p.getLastName()) + "</td><td>" + p.getId() + "</td></tr>"); } response.getWriter().println("</table></p>"); } private void appendAddForm(HttpServletResponse response) throws IOException { // Append form through which new persons can be added response.getWriter() .println( "<p><form action=\"\" method=\"post\">" + "First name:<input type=\"text\" name=\"FirstName\">" + " Last name:<input type=\"text\" name=\"LastName\">" + " <input type=\"submit\" value=\"Add Person\">" + "</form></p>"); } private void doAdd(HttpServletRequest request) throws ServletException, IOException, SQLException { // Extract name of person to be added from request String firstName = request.getParameter("FirstName"); String lastName = request.getParameter("LastName"); if (firstName != null && lastName != null && !firstName.trim().isEmpty() && !lastName.trim().isEmpty()) { Person person = new Person(); person.setFirstName(firstName); person.setLastName(lastName); personBean.addPerson(person); } } }
Con este ultimo paso, se puede ejecutar localmente el proyecto y empezar a almacenar datos en una base de datos HANA. Por el momento se ejecutara localmente, mas adelante se mostrara como actualiza los registros en la base de datos Hana en la nuve (HCP).
Para ejecutar el programa realizar lo siguiente:
Escoger a continuación el servidor Java EE 6 Web:
El servidor empieza a iniciar, mostrando en la siguiente ventana en la parte inferior:
Perspective Java EE
9) Desplegar aplicativo en la nube HCP (Deploy)
El paso para realizar deploy es sencillo y al finalizar se observara los esquemas creados para el aplicativo. Se vera un ejemplo de Select a la base de datos para observar en tiempo real la actualización de la tabla de personas.
Para realizar deploy:
Se seleccionara la plataforma en la nube HCP, para desplegar el aplicativo.
Clic en siguiente. El deploy toma al rededor de 5 minutos.
Clic en finalizar.
Una vez finaliza el Deploy, se agregara el nuevo esquema localmente para poder ver las tablas creadas en la base de datos HANA para posteriormente realizar operaciones SQL.
Para configurar el Host ir a la perspectiva : 
En esta perspectiva seleccionar la pestaña del explorador con el nombre Systems:
Para agregar un nuevo esquema de base de datos realizar lo siguiente:
Aparecera la siguiente pantalla:
Clic en finalizar, y se mostrara el esquema de base de datos correctamente instanciado desde el HCP:
Por el momento dejemos este punto quieto ya que se utilizara mas adelante. Ahora se procede a ingresar al HCP y observar la aplicacion Java creada correctamente:
Clic en el nombre de la aplicacion. Atributos y propiedades de la aplicacion:
Application URLs: Url de la aplicacion a ser ejecutada.
Clic en Data Source Bindings:
El esquema mencionado es el que se configuro en Eclipse.
Con todo lo visto anteriormente, se ejecuta la aplicacion y se procede a agregar datos.
Ahora se mira el esquema para buscar la tabla "T_PERSON" en la cual se están alojados los datos.
Se busca la tabla en la siguiente ruta:
Para realizar un Select a la tabla seguir los siguientes pasos:
Esto genera el Script del Select a la tabla automaticamente:
Clic en el icono verde de la parte superior derecha para ejecutar el Script:
Como se observa en la imagen se obtienen los dos datos ingresados previamente.
SAP HCP MOBILE SERVICES
En esta sección se explicaran los conceptos de HCPms. Referencia: https://help.hana.ondemand.com/hana_cloud_platform_mobile_services/frameset.htm
servicios móviles de la plataforma de la nube de SAP HANA ofrece autenticación, segura en el embarque, las notificaciones push nativas, y generación de informes para aplicaciones móviles de la empresa. Los servicios móvile proporciona un portal web de administración y el seguimiento global único para configurar y gestionar aplicaciones móviles.
1) Habilitar HCP Mobile Services
2) Configuración de SAP HANA Mobile Services
Prerequisitos:
1) Poseer una cuenta HCP
2) Subscripción HTML5 Applications
3) Subscripción Java Applications
4) Habilitar la propiedadPrincipal Propagation 
Trust 
Local Service Provider 
.
5) Configuración Mobile Services:
A continuación, se muestra el enlace para el administrador de HCPms. clic en el enlace:
A continuación se muestra el siguiente panel de administración:
SAP HANA (MDC): CREACION DE BASE DE DATOS Y ESQUEMAS HANA XS EN HCP
Nota: Antes de empezar, es necesario tener una cuenta en HCP trial.
En esta sección se procede a crear un base de datos llamada HANA MDC (Multitenant Database Containers). Pero que tiene de especial esta base de datos, a los esquemas creados anteriormente? Pues bien lo especial consiste en que te brinda una base de datos completa en la cual puedes ver los recursos utilizados en el Sap Hana Database Administration, crear varios esquemas para diferentes aplicaciones, entre otras utilidades.
SAP HANA (MDC) permite alojar múltiples bases de datos SAP HANA en un único sistema SAP HANA. Todas las bases de datos de inquilinos en el mismo sistema comparten los mismos recursos del sistema (memoria y CPU ), pero cada base de datos del arrendatario es totalmente aislado con sus propios usuarios de bases de datos, catálogo, repositorio, persistencia (archivos de datos y archivos de registro) y servicios.
1) Lo primero a realizar es crear la base de datos de la siguiente forma estando en HCP. El proceso puede demorar varios minutos mientras crea la base de datos.
Nota: SAP ofrece como alternativa Windows Azure y Amazon para alojar el SAP Hana Developer Edition. (Muy a tener en cuenta para futuros desarrollos y mas que todo con tecnologia Microsoft)
2) Una vez creada la base de datos se obtiene lo siguiente:
Una vez se da clic en SAP Hana Cockpit aparece el siguiente panel de administración.
Nota: El usuario del Login es "SYSTEM"
Como se observa en la imagen, se tiene un panel de administración en el cual se observa el estado del servidor.
Ahora bien, como actualmente no se tiene ningún usuario configurado, es necesario crear uno nuevo en el panel mostrado anteriormente dando clic en "Manage Roles and Users"
Una vez se da clic en el icono, aparece la siguiente imagen:
Buscar el usuario "SYSTEM"
Aparecera la siguiente ventana:
Se muestra el usuario creado correctamente:
Se selecciona el usuario creado y se procede a agregar los roles necesarios.
Se muestra una ventana en la cual se filtraran los roles de "Developer" y "Admin".
Por ultimo se guardan las configuraciones.
Una vez se apliquen los roles correctamente, es hora de abrir el editor de trabajo.
3) SAP HANA Web-based Development Workbench
Se ingresa con el usuario creado anteriormente.
Nota: Es posible que pida cambiar la clave nuevamente. Muy parecido a SAP ERP.
Nota: Si tienen problemas con los permisos para el usuario nuevo, agregar los roles mencionados anteriormente al usuario "SYSTEM" ingresar con este
al aplicativo.
Ahora continuemos...
Como es muy lento por razones obvias el acceso al entorno de desarrollo web IDE para administra la base de datos HANA, se procede a configurar la conexión respectiva de la base de datos en el Eclipse. (Si tienen problemas ver mas arriba la configuración y agregar conexiones.)
Para agregar la base de datos seguir los siguientes pasos:
Es hora de elegir la base de datos creada previamente:
Si la conexión se a realizado correctamente, se vera algo como esto
4) Creación de paquetes y configuraciones para el proyecto
Creación del nuevo paquete en la siguiente ruta:
Ingresar los siguientes datos:
Después de dar clic en "OK", el paquete se ha creado correctamente.
NOTA: Ahora lo que sigue es de mucho cuidado y se va a poner a prueba el conocimiento visto en la sección "Creación de una aplicacion HANA XS" . Seguir esta sección nuevamente y asociar la aplicacion al paquete creado para hacer Deploy. Una vez realizado esto pueden proceder con la guía.
5) Creación de un proyecto XS
Se crear un proyecto XS en el cual se elegirá el espacio de trabajo Codejam (Es la base de datos creada anteriormente).
Una vez se elige el proyecto a crear aparece la siguiente ventana:
Clic en "Next". Ahora es necesario seleccionar la base de datos en la cual sera alojado el proyecto XS.
Ingresar la siguiente información. Click en finalizar.
A continuación se muestra el proyecto correctamente creado en la base de datos.
Antes de subir la aplicacion, se realizaran algunos pasos. Se creara el esquema de la base de datos para la aplicacion "codejam".
Una vez posicionados en este archivo, se ingresara el siguiente código:
Creación de un archivo CSV para los datos a ser insertados en la base de datos:
Es hora de crear un archivo de importación de datos. Con el objetivo de migrar toda la información del archivo CSV a la base de datos.
A continuación se debe subir la aplicacion al servidor, para esto es necesario activar todos los elementos del proyecto XS.
Nota importante: Configurar los roles. Ver el proyecto XS creado anteriormente. dejare algunas imagenes de como quedo en este proyecto.
Continuando, se procede con la activación del proyecto:
Después de activar es necesario ingresar al administrador de base de datos en HCP con el fin de asignar al usuario el rol creado al activar la aplicacion. Tener en cuenta que esta aplicacion tiene como objetivo principal, la actualizacion automatica de datos desde un archivo CSV a una tabla en HANA, la creación de un esquema y la asignación de roles.
Una vez dentro del administrador de HANA, realizar los siguientes pasos:
Asignación del rol:
Con esto se asigna control sobre el nuevo esquema creado y se podrá visualizar desde Eclipse:
Para comprobar de que la inserción de datos desde el archivo CSV sea correcta, se procede a realizar lo siguiente:
Se ejecuta el Select y al final se observara los los datos importados desde el archivo CSV.
Espero les sirva esta informacion con ejercicios practicos.
Cualquier duda, me pueden contactar en el siguiente Twitter: https://www.twitter.com/locoalien
Saludos,
1 Comment
