The following steps will explain how to create the very first HelloWorld example on SCP Classic using the SAP S/4HANA Cloud SDK. If you want to follow this tutorial, we highly recommend checking out the first part of this blog series.

Note: This post is part of a series. For a complete overview visit the SAP S/4HANA Cloud SDK Overview.

 

Goal of this blog post

This tutorial will cover your first steps when developing applications for SCP CloudFoundry using the SAP S/4HANA Cloud SDK. More specifically, we will cover the following steps:

  1. Create an account for SCP CloudFoundry and setup the CloudFoundry command line interface for deploying and managing CloudFoundry applications.
  2. Generate your first project using the SAP S/4HANA Cloud SDK Maven archetype and understand its structure.
  3. Deploy your first application to SCP CloudFoundry.

The screenshot below shows the final result of this tutorial.

 

Setup for CloudFoundry

In order to deploy applications to SCP CloudFoundry, you can create a free trial account here. You will also need the CloudFoundry command line interface (cf CLI) to deploy and manage your CloudFoundry applications. To install it, you can either grab the latest release on the official release page or use your favorite package manager.

Now you can open your command line and enter the following commands:

cf api https://api.cf.sap.hana.ondemand.com
cf login

The cf CLI will ask you for the API endpoint, your username/mail and your password. After entering these, you should be successfully logged in!

Note: Internal users may be required to set system environment variables.

http_proxy=http://proxy.wdf.sap.corp:8080
https_proxy=http://proxy.wdf.sap.corp:8080

Generate Project from Archetype

To generate your first project from the Maven archetype, run the following command:

mvn archetype:generate -DarchetypeGroupId=com.sap.cloud.sdk.archetypes -DarchetypeArtifactId=scp-cf-tomee -DarchetypeVersion=1.0.0

During the generation process, Maven will require additional parameters to form your project:

groupId an identifier representing your group, company or organization (e.g. com.mycompany.cloud)
artifactId and identifier for your application (e.g. firstapp)
version the version of your application (e.g. 1.0-SNAPSHOT)
package the name of the top-level package your source code will reside in (typically equal to your groupId, e.g. com.mycompany.cloud)
uniqueHostname a unique identifier to determine your initial project URL on CloudFoundry. This value must be individual for each developer and application, but it can easily be changed later on. We recommend Application Name + Global Id: firstapp-D123456

After providing these values, Maven will generate your project from the archetype.

Now you can open your favorite IDE and import the project as ‘Maven Project’. After importing the project into your IDE, the project structure should look like this:

The project consists of two directories, firstapp-app and firstapp-integration-tests.

  • firstapp-app contains the source code and configuration files of your actual application.
src/main/java Here goes your production code, nothing else. As you can see, there’s already the HelloWorldServlet, which we will look at in more detail soon.
src/main/resources Anything that you require in your production code but is no code goes here (typically things like API definition files for RAML or OpenAPI, Database Migration Files for Flyway or Liquibase)
src/main/webapp It contains the deployment descriptor for your web application – the infamous web.xm
src/test/java This is the place for your automated tests.
src/test/resources Tests may also require additional resources to work properly such as configuration files. This is their place.
pom.xml  This is your project management file for Maven where you can maintain other open source dependencies or use plugins that ease your build environment.
manifest.yml  This is the deployment descriptor for CloudFoundry (we will take a closer look at this file when we deploy the application)

 

  • firstapp-integration-tests contains the integration tests for your application. Its structure is similar to firstapp-app.
src/test/java Here you can put all your integration tests. As you can see, there’s already the HelloWorldServiceTest corresponding to the HelloWorldServlet.
src/test/resources Here go all the resources needed for the integration tests to run.

 

HelloWorldServlet

Now that you understand the structure of the project, let’s take a closer look at the HelloWorldServlet.

package com.sap.cloud.sdk.tutorial;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
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 java.io.IOException;
 
@WebServlet("/hello-servlet")
public class HelloWorldServlet extends HttpServlet
{
    private static final long serialVersionUID = 1L;
    private static final Logger logger = LoggerFactory.getLogger(HelloWorldServlet.class);
 
    @Override
    protected void doGet( final HttpServletRequest request, final HttpServletResponse response )
        throws ServletException, IOException
    {
        logger.info("I am running!");
        response.getWriter().write("Hello World!");
    }
}

The HelloWorldServlet extends HttpServlet, so this will be a HTTP endpoint that we can visit. We map this endpoint to the /hello-servlet route using @WebServlet("/hello-servlet"). By overriding the function doGet, we define what happens when a client performs an HTTP GET request on the /hello-servlet route. in this case we simply write a response containing “Hello World!”

Deployment

In order to deploy the application, we first need to assemble our project into a deployable artifact – a .war file. Open your command line and change into the firstapp directory, the root directory of your project and run the following command:

cd /path/to/firstapp
mvn clean package

This tells maven to remove any files from previous assemblies (clean) and to assemble our project (package). The project is setup so that Maven automatically runs our unit and integration tests for us. After running the command there should be a directory target inside of the firstapp-appdirectory, containing a file called firstapp-app-1.0-SNAPSHOT.war. This is the file that we will deploy to CloudFoundry.

Now the previously mentioned manifest.yml comes into play – it’s the deployment descriptor used by CloudFoundry.

---
applications:
 
- name: firstapp
  memory: 512M
  host: firstapp-D123456
  path: target/firstapp-app-1.0-SNAPSHOT.war
  buildpack: sap_java_buildpack
  env:
    TARGET_RUNTIME: tomee
    JBP_CONFIG_REPOSITORY: '[ default_repository_root: "http://xs2repo.cfapps.neo.ondemand.com" ]'
    destinations: '[{name: "ErpQueryEndpoint", url: "https://myerp.com", username: "user", password: "password"}]'

The manifest contains a list of applications that will be deployed to CloudFoundry. In this example we only have one application, firstapp, with the following parameters:

name This is the identifier of your application within your organization and your space in SCP CloudFoundry.
memory The amount of memory allocated for your application.
host Determines the URL of your application after deploying it (this is where the random number from the generation process is being used).
path The relative path to the artifact to be deployed.
buildpack A buildpack is what CloudFoundry uses to build and deploy your application. Since this is a Java application, we use the sap_java_buildpack.
env Here we can provide additional application specific environment variables. For example we specify that we want to use a TomEE container as our target runtime.

Now you can deploy the application by entering the following command:

cf push -f firstapp-app/manifest.yml

cf push is the command used to deploy applications. The -f flag provides cf CLI with the deployment descriptor.

Hint: If you omit the -f flag,  cf CLI will check whether there is a file named manifest.yml in the current directory. If so,  cf CLI will use this file as deployment descriptor. Else, it will fail.

After the deployment is finished, cf CLI’s output should look like this:

Now we can visit the application under its corresponding URL:

Hello world!

That’s it.

Now you have a strong basis for developing your own cloud application for SCP CloudFoundry using the SAP S/4HANA Cloud SDK. Stay tuned for upcoming blog posts about more advanced usages of the SAP S/4HANA Cloud SDK.

To report this post you need to login first.

Be the first to leave a comment

You must be Logged on to comment or reply to a post.

Leave a Reply