Lab Manual

CS6712 – GRID AND CLOUD COMPUTING LABORATORY
Ex. No.1 Develop a new Web Service for Calculator
OBJECTIVE:
To develop a new Web service for Calculator applications.
PROCEDURE:
When we start Globus toolkit container, there will be number of services starts up.
The service for this task will be a simple Math service that can perform basic
arithmetic for a client.
The Math service will access a resource with two properties:
1. An integer value that can be operated upon by the service.
2. A string values that holds string describing the last operation.
The service itself will have three remotely accessible operations that operate upon
value:
(a) add, that adds a to the resource property value.

(b) subtract that subtracts a from the resource property value.
(c) getValueRP that returns the current value of value.
Usually, the best way for any programming task is to begin with an overall
description of what you want the code to do, which in this case is the service
interface. The service interface describes how what the service provides in terms of
names of operations, their arguments and return values. A Java interface for our
service is:
public interface Math {

public void add(int a);
public void subtract(int a);
public int getValueRP();
}
It is possible to start with this interface and create the necessary WSDL file using the
standard Web service tool called Java2WSDL. However, the WSDL file for GT 4 has
to include details of resource properties that are not given explicitly in the interface
above. Hence, we will provide the WSDL file.
Step 1 Getting the Files
All the required files are provided. The MathService source code files can be found
from http://www.gt4book.com
(http://www.gt4book.com/downloads/gt4book-examples.tar.gz)
A Windows zip compressed version can be found at

http://www.cs.uncc.edu/~abw/ITCS4146S07/gt4book-examples.zip. Download
and uncompress the file into a directory called GT4services. Everything is included
(the java source WSDL and deployment files, etc.):
WSDL service interface description file -- The WSDL service interface description
file is provided within the GT4services folder at:
GT4Services\schema\examples\MathService_instance\Math.wsdl
Service code in Java -- Both the code for service operations and for the resource
properties are put in the same class for convenience. More complex services and
resources would be defined in separate classes. The Java code for the service and
its resource properties is located within the GT4services folder at:
GT4services\org\globus\examples\services\core\first\impl\MathService.java.
Deployment Descriptor -- The deployment descriptor gives several different important

sets of information about the service once it is deployed. It is located within the
GT4services folder at:
GT4services\org\globus\examples\services\core\first\deploy-server.wsdd.
Step 2 – Building the Math Service
It is now necessary to package all the required files into a GAR (Grid Archive) file.
The build tool ant from the Apache Software Foundation is used to achieve this as
shown overleaf:
Generating a GAR file with Ant (from http://gdp.globus.org/gt4-
tutorial/multiplehtml/ch03s04.html)
Ant is similar in concept to the UNIX make tool but a java tool and XML based.
Build scripts are provided by Globus 4 to use the ant build file. The windows version
of the build script for MathService is the Python file called globus-build-service.py,
which held in the GT4services directory. The build script takes one argument, the
name of your service that you want to deploy. To keep with the naming convention,
this service will be called first.
In the Client Window, run the build script from the GT4services directory with:
globus-build-service.py first
The output should look similar to the following:

Buildfile: build.xml
.
.
.
.
.
BUILD SUCCESSFUL
Total time: 8 seconds
During the build process, a new directory is created in your GT4Services directory
that is named build. All of your stubs and class files that were generated will be in
that directory and its subdirectories. More importantly, there is a GAR (Grid Archive)
file called org_globus_examples_services_core_first.gar.
The GAR file is the package that contains every file that is needed to successfully
deploy your Math Service into the Globus container. The files contained in the GAR
file are the Java class files, WSDL, compiled stubs, and the deployment descriptor.
Step 3 – Deploying the Math Service
If the container is still running in the Container Window, then stop it using Control-C.
To deploy the Math Service, you will use a tool provided by the Globus Toolkit called
globus-deploy-gar. In the Container Window, issue the command:
globus-deploy-gar org_globus_examples_services_core_first.gar
Successful output of the command is :

The service has now been deployed. Check service is deployed by starting container
from the Container Window. You should see the service called MathService.
Step 4 – Compiling the Client
A client has already been provided to test the Math Service and is located in the
GT4Services directory at:
GT4Services\org\globus\examples\clients\MathService_instance\Client.java
package org.globus.examples.clients.MathService_instance;
import org.apache.axis.message.addressing.Address;
import org.apache.axis.message.addressing.EndpointReferenceType;
import org.globus.examples.stubs.MathService_instance.MathPortType;
import org.globus.examples.stubs.MathService_instance.GetValueRP;
import
org.globus.examples.stubs.MathService_instance.service.MathServiceAddressingL
ocator;
public class Client {
public static void main(String[] args) {
MathServiceAddressingLocator locator = new
MathServiceAddressingLocator()
try {
String serviceURI = args[0];
// Create endpoint reference to service
EndpointReferenceType endpoint = new
EndpointReferenceType();
endpoint.setAddress(new Address(serviceURI));
MathPortType math;
// Get PortType
math = locator.getMathPortTypePort(endpoint);
// Perform an addition
math.add(10);
// Perform another addition
math.add(5);
// Access value
System.out.println("Current value: "
+ math.getValueRP(new GetValueRP()));
// Perform a subtraction
math.subtract(5);
// Access value
System.out.println("Current value: "
+ math.getValueRP(new GetValueRP()));
} catch (Exception e) {
e.printStackTrace();
}
}
}
When the client is run from the command line, you pass it one argument. The
argument is the URL that specifies where the service resides. The client will create
the end point rerference and incorporate this URL as the address.
The end point reference is then used with the getMathPortTypePort method of a
MathServiceAdressingLocator object to obtain a reference to the Math interface
(portType). Then, we can apply the methods available in the service as though they
were local methods Notice that the call to the service (add and subtract method
calls) must be in a “try {} catch(){}” block because a “RemoteException” may be
thrown. The code for the “MathServiceAddressingLocator” is created during the
build process.
(a) Settting the Classpath
To compile the new client, you will need the JAR files from the Globus toolkit in your
CLASSPATH. Do this by executing the following command in the Client Window:
%GLOBUS_LOCATION%\etc\globus-devel-env.bat
You can verify that this sets your CLASSPATH, by executing the command:
echo %CLASSPATH%
You should see a long list of JAR files. Running \gt4\etc\globus-devel-env.bat only
needs to be done once for each Client Window that you open. It does not need to be
done each time you compile.
(b) Compiling Client
Once your CLASSPATH has been set, then you can compile the Client code by
typing in the following command:
javac -classpath
build\classes\org\globus\examples\services\core\first\impl\:%CLASSPATH%
org\globus\examples\clients\MathService_instance\Client.java
Step 5 – Start the Container for your Service
Restart the Globus container from the Container Window with:

globus-start-container -nosec
Step 6 – Run the Client
To start the client from your GT4Services directory, do the following in the Client
Window, which passes the GSH of the service as an argument:
java -classpath
build\classes\org\globus\examples\services\core\first\impl\:%CLASSPATH%
org.globus.examples.clients.MathService_instance.Client
http://localhost:8080/wsrf/services/examples/core/first/MathService
The output will be:

Current value: 15
Current value: 10
Step 7 – Undeploy the Math Service and Kill a Container
Before we can add functionality to the Math Service , we must undeploy the service.
In the Container Window, kill the container with a Control-C. Then to undeploy the
service, type in the following command:
globus-undeploy-gar org_globus_examples_services_core_first
which should result with the following output:

Undeploying gar...
Deleting /.
.
.
Undeploy successful
Step 8 - Adding Functionality to the Math Service
In this final task, you are asked to modify the Math service and associated files so
the service supports the multiplication operation. To do this task, you will need to
modify:
 Service code (MathService.java)
 WSDL file (Math.wsdl)
RESULT:
Thus the web service for Calculator applications has been developed and
deployed.
Ex.No.2. Develop New OGSA-Compliant Web Service
OBJECTIVE:
To develop a new OGSA-compliant web service.
PROCEDURE:
Writing and deploying a WSRF Web Service is easier. We just have to follow five
simple steps:
1. Define the service's interface. This is done with WSDL.

2. Implement the service. This is done with Java.
3. Define the deployment parameters. This is done with WSDD and JNDI.
4. Compile everything and generate a GAR file. This is done with Ant.
5. Deploy service. This is also done with a GT4 tool.
To run this program, as a minimum we will be required to have installed the following
prerequisite software.
1. Download the latest Axis2 runtime from the above link and extract it. Now we point
Eclipse WTP to downloaded Axis2 Runtime. Open Window -> Preferences -> Web
Services -> Axis2 Emitter
2. Select the Axis2 Runtime tab and point to the correct Axis2 runtime location.
Alternatively at the Axis2 Preference tab, you can set the default setting that will
come up on the Web Services Creation wizards. For the moment we will accept the
default settings.
a. Click OK.
b. Next we need to create a project with the support of Axis2 features. Open File ->
New -> Other... -> Web -> Dynamic Web Project
c. Click next
3. Select the name Axis2WSTest as the Dynamic Web project name (you can specify
any name you prefer), and select the configured Tomcat runtime as the target
runtime. Click next.
4. Select the Axis2 Web service facet. Click Finish.

5. This will create a dynamic Web project in the workbench.
6. Import the wtp/Converter.java class into Axis2WSTest/src (be sure to preserve the
package). Build the Project, if it not auto build.
7. Select Converter.java, open File -> New -> Other... -> Web Services -> Web
Service. Click next.
8. The Web service wizard would be brought up with Web service type set to Bottom
up Java bean Web Service with the service implementation automatically filled in.
Move the service scale to Start service.
9. Click on the Web Service runtime link to select the Axis2 runtime. Click OK.
10. Ensure that the correct server and service project are selected as displayed below.
Click next.
11. This page is the service.xml selection page. if you have a custom services.xml, you
can include that by clicking the Browse button. For the moment, just leave it at the
default.
Click next.
12. This page is the Start Server page. It will be displayed if the server has not been
started. Click on the Start Server button. This will start the server runtime.
Click next.
13. This page is the Web services publication page, accept the defaults.
Click Finish.
14. Now, select the Axis2WSTest dynamic Web project, right-click and select Run ->
Run As -> Run on Server to bring up the Axis2 servlet.
Click Next.
15. Make sure you have the Axis2WSTest dynamic Web project on the right-hand side
under the Configured project.
Click Finish.
16. This will deploy the Axis2 server webapp on the configured servlet container and
will display the Axis2 home page. Note that the servlet container will start up
according to the Server configuration files on your workspace.
17. Click on the Services link to view the available services. The newly created
converter Web service will be shown there.
18. Click on the Converter Service link to display the wsdl URL of the newly created
Web service. Copy the URL.
19. Now we'll generate the client for the newly created service by referring the ?wsdl
generated by the Axis2 Server. Open File -> New -> Other... -> Web Services ->
WebServiceClient
20. Paste the URL that was copied earlier into the service definition field.
21. Click on the Client project hyperlink and enter Axis2WSTestClient as the name of
the client project. Click OK.
22. Back on the Web Services Client wizard, make sure the Web service runtime is set
to Axis2 and the server is set correctly. Click Next.
23. Next page is the Client Configuration Page. Accept the defaults and click Finish.
24. The Clients stubs will be generated to your Dynamic Web project
Axis2WSTestClient.
25. Now we are going to write Java main program to invoke the client stub. Import the
ConverterClient.java file to the workspace into the wtp package in the src folder of
Axis2WSTestClient.
26. Then select the ConverterClient file, right-click and select Run As -> Java
Application. Here's what you get on the server console:
27. Another way to test and invoke the service is to select Generate test case to test
the service check box on the Axis2 Client Web Service Configuration Page when
going through the Web Service Client wizard.
28. If that option is selected, the Axis2 emitter will generate JUnit testcases matching
the WSDL we provide to the client. These JUnit testcases will be generated to a
newly added source directory to the Axis2WSTestClient project called test.
Next thing we need to do is to insert the test case with the valid inputs as the Web
service method arguments. In this case, let's test the
ConverterConverterSOAP11Port_httpTest.java by provide values for Celsius and
Farenheit for the temperature conversion. As an example, replace the generated TODO
statement in each test method to fill in the data with values as:
testfarenheitToCelsius() -> farenheitToCelsius8.setFarenheit(212);

testStartfarenheitToCelsius() ->farenheitToCelsius8.setFarenheit(212);
testcelsiusToFarenheit() -> celsiusToFarenheit10.setCelsius(100);
testStartcelsiusToFarenheit() -> celsiusToFarenheit10.setCelsius(100);
Here the testcases were generated to test both the synchronous and asynchronous
clients.
29. After that, select the testcase, right-click, select Run As -> JUnit Test. You will be
able to run the unit test successfully invoking the Web service.
The Web Service wizard orchestrates the end-to-end generation, assembly,

deployment, installation and execution of the Web service and Web service client. Now
that your Web service is running, there are a few interesting things you can do with this
WSDL file. Examples:
We can choose Web Services -> Test with Web Services Explorer to test the
service.
We can choose Web Services -> Publish WSDL file to publish the service to a
public UDDI registry.
RESULT:
Thus the development of a new OGSA-compliant web service was executed

successfully.
Ex.No.3 Using Apache Axis develop a Grid Service
OBJECTIVE:
To develop a Grid Service using Apache Axis.
PROCEDURE:
We will need to download and install the following software:

1. Java 2 SDK v1.4.1, http://java.sun.com/j2se/1.4.1/download.html
2. Apache Tomcat v4.124
http://jakarta.apache.org/builds/jakarta-tomcat-4.0/release/v4.1.24/bin/jakarta/
tomcat4.1.24.exe.
3. XML Security v1.0.4, http://www.apache.org/dist/xml/security/java-library/xmlsecurity
bin1.0.4.zip
4. Axis v1.1, http://ws.apache.org/axis/dist/1_1/axis-1_1.zip
1. Java 2 SDK
Run the downloaded executable (j2sdk-1_4_1-windows-i586.exe) which will install
the SDK in C:\j2sdk1.4.1. Set the JAVA_HOME environment variable to point to this
directory as follows:
Click on START->CONTROL PANEL->SYSTEM
Click on the Advanced tab
Click on the Environment Variables button
Click on the New… button in the user variable section and enter the details
Add the Java binaries to your PATH variable in the same way by setting a user
variable called PATH with the value “%PATH%;C:\j2sdk1.4.1\bin”
2. Apache Tomcat
Run the downloaded executable (jakarta-tomcat-4.1.24.exe), and assume the

installation directory is C:\jakarta-tomcat-4.1.24.
Edit C:\ jakarta-tomcat-4.1.24\conf\tomcat-users.xml and create an “admin” and
“manager” role as well as a user with both roles. The contents of the file should be
similar to:
<?xml version='1.0' encoding='utf8'?>
<tomcat-users>
<role rolename="manager"/>
<role rolename="admin"/>
<user username="myuser" password="mypass" roles="admin,manager"/>
</tomcat-users>
Start Tomcat by running C:\ jakarta-tomcat-4.1.24\bin\startup.bat and test it by

browsing http://localhost:8080/
Stop Tomcat by running C:\ jakarta-tomcat-4.1.24\bin\shutdown.bat.
3. XML Security
Download and unzip
http://www.apache.org/dist/xml/security/javalibrary/xmlsecurity-bin 1_0_4.zip
Copy xml-sec.jar to C:\axis-1_1\lib\
Set-up your CLASSPATH environment variable to including the following:
C:\axis1_1\lib\xml-sec.jar;
4. Apache Axis
Unzip the downloaded Axis archive to C: (this will create a directory C:\axis-1_1).
Extract the file xmlsec.jar from the downloaded security archive to
C:\axis1_1\webapps\axis\WEB-INF\lib.
Set-up your CLASSPATH environment variable to including the following:

 The current working directory
 All the AXIS jar files as found in C:\axis-1_1\lib
C:\jakarta-tomcat-4.1.24\common\lib\servlet.jar
Your CLASSPATH should therefore look something like:
C:\axis-1_1\lib\axis.jar;
C:\axis 1_1\lib\axis-ant.jar;
C:\axis-1_1\lib\commons-discovery.jar;
C:\axis-1_1\lib\commons-logging.jar;
C:\axis-1_1\lib\jaxrpc.jar;
C:\axis-1_1\lib\log4j-1.2.8.jar;
C:\axis-1_1\lib\saaj.jar;
C:\axis-1_1\lib\wsdl4j.jar;
C:\axis-1_1\lib\xercesImpl.jar
C:\axis-1_1\lib\xmlParserAPIs.jar;
C:\jakarta-tomcat-4.1.24\common\lib\servlet.jar
C:\axis-1_1\lib\xml-sec.jar;
Now tell Tomcat about your Axis web application by creating the file
C:\jakarta- tomcat-4.1.24\webapps\axis.xml with the following content:
<Context path="/axis" docBase="C:\axis-1_1\webapps\axis" debug="0"
privileged="true">
<LoggerclassName="org.apache.catalina.logger.FileLogger"prefix="axis_lo."
suffix=".txt" timestamp="false"/>
5. Deploy a Sample Web service packaged within Axis installations

Deploy one of the sample Web Services to test the system and to create the C:\axis-
1_1\webapps\axis\WEB-INF\server-config.wsdd file. From C:\axis-1_1 issue the
command (on one line):
java org.apache.axis.client.AdminClient
http://localhost:8080/axis/services/AdminService/samples/stock/deploy.wsdd
This should return the following:
.- Processing file samples/stock/deploy.wsdd
.- <Admin>Done processing</Admin>
RESULT:
Thus the development of a Grid Service using Apache Axis is executed successfully.
Ex.No.4 Develop applications using Java or C/C++ Grid APIs
OBJECTIVE:
To develop an applications using Java or C/C++ Grid APIs.
SAMPLE CODE:
import AgentTeamwork.Ateam.*;
import MPJ.*;
public class UserProgAteam extends AteamProg {
private int phase;
public UserProgAteam( Ateam o )
{}
public UserProgAteam( )
{}
// real const
public UserProgAteam( String[] args ) {
phase = 0;
}
// phase recovery
private void userRecovery( ) {
phase = ateam.getSnapshotId( );
}
private void compute( ) {
for ( phase = 0; phase < 10; phase++ ) {
try {
Thread.currentThread( ).sleep( 1000 );
}
catch(InterruptedException e ) {
}
ateam.takeSnapshot( phase );
System.out.println( "UserProgAteam at rank " + MPJ.COMM_WORLD.Rank( ) + " : took a
snapshot " + phase );
}
}
public static void main( String[] args ) {
System.out.println( "UserProgAteam: got started" );
MPJ.Init( args, ateam);
UserProgAteam program = null;
// Timer timer = new Timer( );
if ( ateam.isResumed( ) ) {
program = ( UserProgAteam )
ateam.retrieveLocalVar( "program" );
program.userRecovery( );
}
else
{
program = new UserProgAteam( args );
ateam.registerLocalVar( "program", program );
}
program.compute( );
MPJ.Finalize( );
}
// application body private void compute( ) {
for ( phase = 0; phase < 10; phase++ ) {
try {
Thread.currentThread( ).sleep( 1000 );
}
catch(InterruptedException e ) {
}
ateam.takeSnapshot( phase );
System.out.println ( "UserProgAteam at rank " + MPJ.COMM_WORLD.Rank( ) + " : took a
snapshot " + phase );
}}
Socket sample code – within some function body

import AgentTeamwork.Ateam.GridTcp.*;
private final int port = 2000;
private GridSocket socket; private
GridServerSocket server; private InputStream
input; private OutputStream output;
for ( int i = start; i < start + trans; i++ ) {
try {
output.write( i % 128 );
} catch ( IOException e ) {
}
System.out.println ( "Sockets with " + myRank + ": " + " output[" + i + "]=" + i % 128 );
}
for ( int i = start; i < start + trans; i++ ) {
try {
System.out.println ( "Sockets with " + myRank + ": " + " input[" + i + "]=" + input.read( ) );
}
catch ( IOException e ) {
}}
MPI sample code

import AgentTeamwork.Ateam.*;
import MPI.*;
// application body private void compute( ) {
}
public static void main( String[] args ) {
MPJ.Init( args, ateam );
program.compute( ); MPJ.Finalize( );
}
}
C/C++ compile.sh – Helloworld.cpp

#!/bin/sh
rm -f *.class
javac -classpath MPJ.jar:Ateam.jar:. *.java
# jar cvf GridJNI.jar *.class jar -cvf
GridJNI.jar *.class javah -jni JavaToCpp
g++ -rdynamic JavaToCpp.cpp -o _libJavaToCpp.so_ -shared -ldl g++ -shared -o
_libHelloWorld.so_ GridJNI_library.cpp
HelloWorld.cpp
C/C++ MPI sample code – Helloworld.cpp

#include <iostream.h>
using namespace std;
typedef int MPI_Request, MPI_Status, MPI_Comm;
extern void takeSnapshot(int argc);
extern int MPI_Init(int* argc, char*** argv);
extern void MPI_Finalize();
extern int MPI_Comm_rank(MPI_Comm comm, int *rank);
extern int MPI_Comm_size(MPI_Comm comm, int *size);
int main(int argc, char** argv) {
cerr << "main" << endl;
cerr << "argc = " << argc << endl;
cerr << "argv[0] = " << argv[0] << endl; cerr << "argv[1] = "
<< argv[1] << endl; MPI_Init(&argc, &argv);
cout << "MPI Init Successful!" << endl;
cout << "[HelloWorld.cpp]Calling Rank() and Size()" << endl;
int rank, size;
MPI_Comm_rank(0,&rank);
MPI_Comm_size(0,&size);
cout << "[HelloWorld.cpp]Rank = " << rank << endl;
cout << "[HelloWorld.cpp]Size = " << size << endl; cerr << "Calling
MPI_Finalize()" << endl; MPI_Finalize();
cerr << "finished" << endl;
}
RESULT:
Thus the development of applications using Java or C/C++ Grid APIs is executed
successfully
Ex.No.5 Develop secured applications using basic security mechanisms

available in Globus Toolkit
OBJECTIVE:
To develop a secured applications using basic security mechanisms available in

Globus.
PROCEDURE:
The Globus Toolkit's Authentication and Authorization components provide the
de facto standard for the "core" security software in Grid systems and applications.
These software development kits (SDKs) provide programming libraries, Java classes,
and essential tools for a PKI, certificate-based authentication system with single sign-on
and delegation features, in either Web Services or non-Web Services frameworks.
("Delegation" means that once someone accesses a remote system, he can give the
remote system permission to use his credentials to access others systems on his
behalf.)
WEB SERVICES AUTHENTICATION AND AUTHORIZATION –
A Web services implementation of the Grid Security Infrastructure (GSI),

containing the core libraries and tools needed to secure applications using GSI
mechanisms. The Grid is a term commonly used to describe a distributed computing
infrastructure which will allow "coordinated resource sharing and problem solving in
dynamic, multi-institutional virtual organizations" . The protocols and middleware to
enable this Grid infrastructure have been developed by a number of initiatives, most
notably the Globus Project .
Web Services are simply applications that interact with each other using Web
standards, such as the HTTP transport protocol and the XML family of standards. In
particular, Web Services use the SOAP messaging standard for communication
between service and requestor. They should be self-describing, self-contained and
modular; present a platform and implementation neutral connection layer; and be based
on open standards for description, discovery and invocation.
The Grid Security Infrastructure (GSI) is based on the Generic Security Services
API (GSS-API) and uses an extension to X509 certificates to provide a mechanism to
authenticate subjects and authorise resources. It allows users to benefit from the ease
of use of a single sign-on mechanism by using delegated credentials, and time-limited
proxy certificates. GSI is used as the security infrastructure for the Globus Toolkit.
Recently, a new proposal for an Open Grid Services Architecture (OGSA) was
announced which marries the Grid and Web Services to create a new Grid Services
model. One problem, which has not yet been explicitly addressed, is that of security. A
possible solution is to use a suitably secure transport binding, e.g. TLS, and extend it to
incorporate appropriate support for proxy credentials. It would be useful to test out some
of the principles of Grid Services using the currently available frameworks and tools for
developing Web Services. Unfortunately, no standards currently exist for implemented
proxy credential support to provide authenticated communication between web
services. A number of XML/Web Services security standards are currently in
development, e.g. XML Digital Signatures, SAML, XKMS, XACML, but the remainder of
this document describes an approach proposed by ANL to use GSI over an SSL link.
A generic Job Submission environment, GAP enables researchers and scientists to
execute their applications on Grid from a conventional web browser. Both Sequential
and Parallel jobs can be submitted to GARUDA Grid through Portal. It provides a
web interface for viewing the resources, and for submitting and monitoring jobs.
Pre-requisites for using GAP

Portal users need to set the following in their ~/.bashrc file.
export GLOBUS_LOCATION=/opt/asvija/GLOBUS-4.0.7/
source /opt/asvija/GLOBUS-4.0.7/etc/globus-user-env.sh
export PATH=/usr/local/jdk1.6.0_10/bin:
GW_LOCATION/bin:/opt/garudaresv/bin:/opt/voms_client/bin:$PATH
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/voms_client/lib:
Accessing GAP
Type http://192.168.60.40/GridPortal1.3/ (to access the Portal through GARUDA
Network) or http://203.200.36.236/GridPortal1.3 (to access the Portal through Internet)
in the address bar of the web browser to invoke the Portal. It is preferable to access
the Portal through GARUDA Network, since it is much faster than the Internet.
In order to access the facilities of Grid Portal such as Job Submission, Job Status
tracking, Storing(Uploading) of Executables and View Output/Error data, the user has
to login into the
Portal using the User's Login Form in the Home page of the Portal.
a) New users are required to click Sign up in the User Login Form, which leads them
to home page of Indian Grid Certification Authority (IGCA) (http://ca.garudaindia.in/).
Click on Request Certificate and acquire the required user/host certificate(s),
details are provided in IGCA section.
b) Registered users are required to provide User Id and Password for logging into the
Portal and access various facilities.
Job Management
User can submit their job, monitor the status and view output files using the Job
Management interfaces. Types of job submission (Basic and Advanced) and Job
information are covered under this section.
Basic Job Submission

This interface can be used to submit sequential as well as parallel jobs. The user
should provide the following information:
1. Optional Job Name - User can provide a suitable (alias) name for their job.
2. Type of Job user want to execute,
3. Operating System – Required for their Job,
4. 'Have you reserved the Resources' - An optional parameter contains the
Reservation Id's that can be used for job submission instead of choosing the
Operating System/Processor parameter.
5. No. of processes required for the job - This parameter is only for the
parallel applications that require more than one CPU.
6. Corresponding Executables – uploaded from either local or remote machine,
7. Input file, if required - The executable and the input file can either be uploaded
from the local machine or can be selected from the Remote File List, if it is
available in the Submit Node
8. STDIN - Required when the user wants to provide any inputs to the application
during the runtime.
9. Optional Execution Time - Here the Execution Time is the anticipated job
completion time.
10. Any Command Line arguments or Environment Variables, if required.
11. User Specific Output/ Error files - If the application generates output/error files
other than standard output/error files and its entries should be separated by comma's
or single empty space in case of multiple files.
All those fields marked with * are mandatory fields and should be filled before
submitting a job. By clicking on submit button, the portal submits the job to Grid
Way Meta Scheduler, which then schedules the job for execution and returns the Job
Id. The Job Id has to be noted for future reference to this job. In the event of
unsuccessful submission, the corresponding error message is displayed.
All those fields marked with * are mandatory fields and should be filled before
submitting a job. By clicking on submit button, the portal submits the job to GridWay
Meta Scheduler, which then schedules the job for execution and returns the Job Id.
The Job Id has to be noted for future reference to this job.
Advanced Job Submission
This interface is provided for the user to submit their Sequential and Parallel
Jobs. The difference from Basic job submission being: it is using GT4 Web Services
components for submitting jobs to the Grid instead of Gridway as scheduler.
The user is provided with two modes in this interface:

1. Default mode - Portal creates the XML file for the user.
2. Second mode, recommended for advanced users - The user can provide their-own
XML file as the executable, provided the required files are available in the submit node.
The user can view the status of the job submitted through Portal and the output file of
the job by specifying the Job Id. The option for downloading the Output/ Error file is
also provided, after the job execution. To cancel any of the queued jobs, the user
has to select the job and click Cancel Job button, following which the
acknowledgment for the job canceled is provided.
Job Info
The user can view the status of the job submitted through Portal and the output file of
the job by specifying the Job Id. The option for downloading the Output/ Error file is
also provided, after the job execution. To cancel any of the queued jobs, the user
has to select the job and click
Cancel Job button, following which the acknowledgment for the job canceled is
provided.
Resources
The GridWay meta-scheduler provides the following information - Node Name, Head
Node, OS, ARCH, Load Average, Status, Configured Process and Available Process.
This information aids user to select a suitable cluster and reserve them in advance for
job submission.
Steps for Reservation of Resources

1. Check the available free resources with valid parameters (Start Time and End Time –
duration for which the resource needs to be reserved). The input fields No. of CPUs
and OS entries are optional.
Example: starttime= 2009-04-02 17:06:53 endtime=2009-04-02 19:07:10
No. of CPUs=2 OS NAME=Linux
2. Choose the Available Process required for the job. Example: Available
Procs = 4
3. Select the required resource from the available list of
resources.
4. Book the resources for reserving a resource for the requested period of time
and process.
5. The reserved resources can be modified/
canceled.
6. Once the reservation process is successfully completed, the Reservation Id is
displayed and is made available in the Basic Job Submission page.
File browser
For the logged-in user, the File Browser lists files, such as the uploaded executables
and Input/Output/Error files, along with their size and last modified information. It also
allows deletion of files.
Accounting
This module provides Accounting information of the jobs that are submitted to
GARUDA, such as no. of jobs submitted, and system parameters such as Memory
usage, Virtual memory, Wall Time, and CPU time. Last one month data is displayed by
default.
MyProxy
MyProxy allows user to upload their Globus Certificates into Myproxy Server and the
same can be used for initializing the Grid proxy on the Grid. If the certificate has been
already generated for you, but you do not have access to the above- mentioned files,
you can download it from GridFS machine (from $HOME/.globus directory) using
winscp/scp.
MyProxy Init
By default, the "Myproxy Init" option is enabled for the user. Upload proxy by entering
valid inputs - User name, Grid-proxy Passphrase, User certificate file (usercert.pem),
User key file (userkey.pem) and Proxy life time (168 hours is the default value).
MyProxyGet
Grid proxy will be initialized on the Grid head node by providing the inputs - User
name, Myproxy Passphrase and Life time of the certificate.
VOMS Proxy
The Virtual Organization Management System (VOMS) allows users to belong to
Virtual Organizations (VOs), thereby allowing them to utilize resources earmarked for
those VOs.
The user can also request for a new VO by using "Request for VO" link. VOMS proxy
initialization with Multiple roles is provided to the user, by selecting more than one
entry on the Role combo box.
Steps to be followed to access GSRM from gridfs:

Login to gridfs(192.168.60.40)
Upload your IGCA user certificates
Initialize proxy with grid-proxy-init
Set environmental variables, respectively for whichever client to be used.
Run the SRM commands
GSRM Access points
pvfs2 (172.20.1.81) node should be used to just test all the available SRM client
interfaces like StoRM, DPm, BestMan.
gridfs (192.168.60.40) node should, if the user wishes to use GSRM storage for
job execution. Users can download/Upload input/output files into GSRM while
submitting jobs from gridfs.
Following Access mechanisms are available at above mentioned nodes to access
GSRM:
1. gridfs(192.168.60.40) : gridfs is the Bangalore GARUDA head node. GSRM
services can be accessed from here using StoRM command line interface.
If the user wants to use the clientSRM ( StoRM Clients) from gridfs machine
Create a valid user proxy using grid-proxy-init
Set the env variable for Globus location path
export GLOBUS_LOCATION= GLOBUS_LOCATION:/usr/local/GARUDA/GLOBUS-
4.0.7/
export PATH=$PATH:/opt/gsrm-client/srmv2storm/bin
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/gsrm- client/cgsi_soap/lib

Run the clientSRM command
2. pvfs2 (172.20.1.81): pvfs2 is the GSRM testing node with the following client
interfaces installed.
Bestman Java APIs

DPM C APIs
3. GSRM Web Client is accessible from any of the user machines reachable to
GSRM server (xn05.ctsf.cdac.org.in), using URL --
https://xn05.ctsf.cdac.org.in/GSRM Client Interfaces
StoRM Command Line Client

1. StoRM command line client format:
clientSRM <requestName> <requestOptions>
2. To get help for clientSRM commands:
clientSRM –h
3. Command to ping to GSRM server:
clientSRM ping -e <GSRM end point>
Bestman Command Line Clients

1. Command to ping to GSRM server src-ping –servicer
httpg://xn05.ctsf.cdac.org.in:8446/dpm/ctsf.cdac.org.in/home/garuda
2. Upload file to GSRM server src-copy <src uri> <target uri> <service uri>
Pre-requisites for using SOA compiler

1. Java Run Time Environment (JDK1.6+)
2. Web Browser with Java web start support
Compiler GUI
The users are required to adhere to following directory structure. Application Parent
Dir- src/,bin/,lib/,include/
1) Login
This method is for logging in to the GARUDA.
Inputs
user name MyProxy User Name
password MyProxy Password
life time Indicates how long is the proxy's life time
Output
Proxy string Proxy issued by the My proxy server
Login status Indicates the status of the operation
Last Login Time Gives when this user was last logged in
Current Login Time Gives users logging in time
2) uploadProxy
This method uploads a proxy that is generated using other tools, to the MyProxy
Server.
Inputs
proxyBytes Existing proxy file is given as byte array
Output
uploadStatus Indicates the status of the operation
3) storeCredential
This method is used for uploading the credentials that is the PKCS12 certificate
directly to the MyProxy Server. It will convert the PKCS12 to certificate and stores in
server for users to download the proxy until it expires.
Inputs
p12Bytes PKCS12 file as byte array
Output
storeStatus Indicates the status of the operation
RESULT:
Thus the development of secured applications using basic security mechanisms

available in Globus is executed successfully.
Ex.No.6 Develop a Grid portal, where user can submit a job and get the result.
Implement it with and without GRAM concept
OBJECTIVE:
To develop a Grid portal, where user can submit a job and get the result and to
implement it with and without GRAM concept.
PROCEDURE:
1. Opening the workflow editor
The editor is a Java Webstart application download and installation is only a click.
2. Java Webstart application

Download and install
3. Job property window:
4. The information system can query EGEE and Globus information systems
5. List of available grids
6. Computing resources of such a grid
7. Broker resource selection

-> Select a Broker Grid for the job
-> Specify extra ranks and requirements for the job in Job description language.
-> The broker will find the best resource for your job.
8. Defining input/output data for jobs

File type
Input: required by the job
Output: produced by the job
File location:
local: my desktop
remote: grid storage resource
File name:
Unique name of the file
File storage type:
Permanent: final result of WF
Volatile: only used for inter-job data transfer
9. Executing workflows with the P-Grade portal

Download proxies
10. Downloading a proxy

11. Associating the proxy with a grid

12. Browsing Proxies
13. Workflow execution

Workflow portlet
14. Observation by the workflow portlet

15. Downloading the results

RESULT:
Thus the development of a Grid portal, where user can submit a job and get the
result and to implement it with and without GRAM is executed successfully.
Ex.No.7
FIND PROCEDURE TO RUN THE VIRTUAL MACHINE OF DIFFERENT
CONFIGURATION. CHECK HOW MANY VIRTUAL MACHINES CAN BE UTILIZED
AT PARTICULAR TIME
OBJECTIVE:
To understand the procedure to run the virtual machine of different configuration.
Check how many Virtual machines can be utilized at particular time.
PROCEDURE:
KVM INSTALLTION
Check that your CPU supports hardware virtualization

To run KVM, you need a processor that supports hardware virtualization. Intel and
AMD both have developed extensions for their processors, deemed respectively
Intel VT-x (code name Vanderpool) and AMD-V (code name Pacifica). To see if your
processor supports one of these, you can review the output from this command:
$ egrep -c '(vmx|svm)' /proc/cpuinfo

If 0 it means that your CPU doesn't support hardware virtualization.
If 1 (or more) it does - but you still need to make sure that virtualization is enabled in
the BIOS.
Use a 64 bit kernel (if possible)

Running a 64 bit kernel on the host operating system is recommended but not
required.
To serve more than 2GB of RAM for your VMs,you must use a 64-bit kernel, On a
32-bit kernel install, you'll be limited to 2GB RAM at maximum for a given VM.
To see if your processor is 64-bit, you can run this command:
$ egrep -c ' lm ' /proc/cpuinfo
If 0 is printed, it means that your CPU is not 64-bit.

If 1 or higher, it is.
Now see if your running kernel is 64-bit, just issue the following command:
$ uname –m
x86_64 indicates a running 64-bit kernel. If you use see i386, i486, i586 or i686, you're
running a 32-bit kernel.
$ ls /lib/modules/3.16.0-30- generic/kernel/arch/x86/kvm/kvm
kvm-amd.ko : AMD Processor

kvm-intel.ko : Intel Processor
kvm.ko : Kernel object

$ ls /dev/kvm
/dev/kvm
Install Necessary Packages

1. qemu-kvm
2. libvirt-bin
3. bridge-utils
4. virt-manager
5. qemu-system
$ sudo apt-get install qemu-kvm
$ sudo apt-get install libvirt-bin
$ sudo apt-get install bridge-utils
$ sudo apt-get install virt-manager
$ sudo apt-get install qemu-system
To check package installation Check

$ dpkg –l|grep qemu-kvm
$ virsh
virsh# exit
Verify Installation
You can test if your install has been successful with the following command:
$ virsh -c qemu:///system list
Id Name State
----------------------------------
If on the other hand you get something like this:
$ virsh -c qemu:///system list
libvir: Remote error : Permission denied
error: failed to connect to the hypervisor
virsh # version
virsh # node info
Creating VMS
$ virt-install --connect qemu:///system -n hardy -r 512 -f hardy1.qcow2 -s 12 -c
ubuntu-14.04.2-server-amd64.iso --vnc --noautoconsole --os-type linux --os-variant
ubuntuHardy
(or)
Open disk image Error
$ sudo chmod 777 hardy.gcow2
To run
$ virt-install --connect qemu:///system -n hardy -r 512 -f hardy1.qcow2 -s 12 -c
ubuntu-14.04.2-server-amd64.iso --vnc --noautoconsole --os-type linux --os-variant

ubuntuHardy
$ sudo virt-manager
To Run Virtual Machine
To Login in Guest OS
TO RUN VM IN OPEN STACK
Step 1 : Under the Project Tab, Click Instances. In the right side screen Click Launch Instance.
Step 2 : In the details, Give the instance name (eg. Instance1).

Step 3: Click Instance Boot Source list and choose 'Boot from image'
Step 4: Click Image name list and choose the image currently uploaded.
Step 5: Click launch.
Your VM will get created.
OPEN STACK INSTALLATION
$ free –m - its shows the RAM Usage

$ sudo adduser stack - password: stack
$ sudo apt-get install sudo - for updating SU
$ sudo –I - entering into the root user
# echo "stack ALL=(ALL) NOPASSWD: ALL">> /etc/sudoers - it changes the stack
from normal users to super user
#cat /etc/sudoers -To check last line as - (stack ALL =(ALL)
NOPASSWORD:ALL)
#exit - logout from root user
log off your machine and login as stack user

Prerequiste- to install git open all the ports
$ sudo apt-get install git

$ git clone https:git.openstack.org/openstack-dev/devdstack
$ ls - devstack should there
$ cd devstack
$ ls - it shows all the files in devstack
$ls –l - longlisting the devstack files
$ nano local.conf - paste in local.conf
[[local|localrc]]
FLOATING_RANGE=192.168.1.224/27
FIXED_RANGE=10.11.12.0/24
FIXED_NETWORK_SIZE=256
FLAT_INTERFACE=eth0
ADMIN_PASSWORD=root
DATABASE_PASSWORD=root
RABBIT_PASSWORD= root
SERVICE_PASSWORD= root
SERVICE_TOKEN= root save and quit
$ ls –l - should be stack stack
$ ./stack.sh - if error number 181 comes go to vi stack.sh add next to UMASK 022
FORCE=yes
$ pwd
/home/stack/devstack
Devstack$ mv local.conf ../
$ cd ..
Stack$ rm –rf devstack/ /opt/stack/
$ git clone https:git.openstack.org/openstack-dev/devdstack –b stable/kilo
$ cd devstack
$ ll
$ mv ../local.conf .
$ ls –l local.conf
$ ./stack.sh
$ nano stack.sh edit
#make sure unmask is sane
Add FORCE=yes save and exit
$ ./unstack.sh
$ ./clean.sh
Run DevStack:
$ ./stack.sh
Find User name, Password, IP address
In browser give your machines ip http://<ip Address>

Re-Starting Openstack
$ ./rejoin.sh
$ ps -ef|grep devstack it shows all the processes running
End all the processes.
RESULT:
Thus the procedure to run the virtual machine of different configuration is executed
successfully.
Ex.No.8 FIND PROCEDURE TO ATTACH VIRTUAL BLOCK TO THE VIRTUAL

MACHINE AND CHECK WHETHER IT HOLDS THE
DATA EVEN AFTER THE RELEASE OF THE VIRTUAL MACHINE
OBJECTIVE:
To write the procedure to attach virtual block to the virtual machine and check
whether it holds the data even after the release of the virtual machine.
PROCEDURE:
Volumes are block storage devices that you attach to instances to enable
persistent storage. You can attach a volume to a running instance or detach a volume
and attach it to another instance at any time. You can also create a snapshot from or
delete a volume. Only administrative users can create volume types.
Create a volume
1. Log in to the dashboard.
2. Select the appropriate project from the drop down menu at the top left.
3. On the Project tab, open the Compute tab and click Volumes category.
4. Click Create Volume.
In the dialog box that opens, enter or select the following values.
Volume Name: Specify a name for the volume.

Description: Optionally, provide a brief description for the volume.
Volume Source: Select one of the following options:
 No source, empty volume: Creates an empty volume. An empty volume does
not contain a file system or a partition table.
 Image: If you choose this option, a new field for Use image as a source displays.
You can select the image from the list.
Volume: If you choose this option, a new field for Use volume as a source displays.
You can select the volume from the list. Options to use a snapshot or a volume as the
source for a volume are displayed only if there are existing snapshots or volumes.
Type: Leave this field blank.

Size (GB): The size of the volume in gigabytes. (GB).
Availability Zone: Select the Availability Zone from the list. By default, this value is set
to the availability zone given by the cloud provider.
For some cases, it could be nova.
5. Click Create Volume.

The dashboard shows the volume on the Volumes tab.
On the Project tab, open the Compute tab and click the Volumes category.
6. Select the volume and click Manage Attachments.
7. Click Detach Volume and confirm your changes.
A message indicates whether the action was successful.
Create a snapshot from a volume

4. Select a volume from which to create a snapshot.
5. In the Actions column, click Create Snapshot.
6. In the dialog box that opens, enter a snapshot name and a brief description.
7. Confirm your changes.
The dashboard shows the new volume snapshot in Volume Snapshots tab.
Edit a volume
4. Select the volume that you want to edit.
5. In the Actions column, click Edit Volume.
6. In the Edit Volume dialog box, update the name and description of the volume.
7. Click Edit Volume.
Note
You can extend a volume by using the Extend Volume option available in the More
dropdown list and entering the new value for volume size.
Delete a volume¶
When you delete an instance, the data in its attached volumes is not deleted.
Attach a volume to an instance

After you create one or more volumes, you can attach them to instances. You can
attach a volume to one instance at a time.
4. Select the volume to add to an instance and click Manage Attachments.
5. In the Manage Volume Attachments dialog box, select an instance.
6. Enter the name of the device from which the volume is accessible by the instance.
Note: The actual device name might differ from the volume name because of hypervisor
settings
7. Click Attach Volume.
The dashboard shows the instance to which the volume is now attached and the device
name.
You can view the status of a volume in the Volumes tab of the dashboard. The volume
is either Available or In-Use.
Now you can log in to the instance and mount, format, and use the disk.
Detach a volume from an instance

4. Select the check boxes for the volumes that you want to delete.
5. Click Delete Volumes and confirm your choice.
A message indicates whether the action was successful.
RESULT:
Thus the procedure to attach virtual block to the virtual machine and check
whether it holds the data even after the release of the virtual machine is executed
successfully.
Ex.No.9 INSTALL A C COMPILER IN THE VIRTUAL MACHINE AND EXECUTE A

SAMPLE PROGRAM.
OBJECTIVE:
To install a C compiler and execute a sample program in the virtual machine.
PROCEDURE:
Step 1: To login into Guest OS in KVM
Step 2: To write and execute your own C Program in gcc compiler.

Install c compiler using commands.
$ apt-get install gcc
RESULT:
Thus the installation of a C compiler and execution of a C program in the virtual

machine is executed successfully.
Ex.No.10 SHOW THE VIRTUAL MACHINE MIGRATION BASED ON THE CERTAIN

CONDITION FROM ONE NODE TO THE OTHER
OBJECTIVE:
To learn virtual machine migration based on the certain condition from one node
to the
other.
PROCEDURE:
To demonstrate virtual machine migration, two machines must be configured in
one cloud.
MIGRATION LIMITATIONS
Openstack has two commands specific to virtual machine migration:
nova migrate $UUID
nova live-migration $UUID $COMPUTE-HOST
The nova migrate command shuts down an instance to move it to another
hypervisor.
The instance is down for a period of time and sees this as a regular shutdown. It is
not possible to specify the compute host you want to migrate the instance to.
This command does not require shared storage, the migrations can take a long time.
The Openstack cluster chooses the target hypervisor machine based on the free
resources and availability.
The migrate command works with any type of instance. The VM clock has no issues.
The nova live-migration command has almost no instance downtime.
The instance is suspended and does not see this as a shutdown.
The live-migration lets you specify the compute host you want to migrate to, however
with some limitations. This requires shared storage, instances without a configdrive
when block storage is used, or volume-backed instances.
The migration fails if there are not enough resources on the target hypervisor
The VM clock might be off.
Here are some examples when to use which option:

If it is important to choose the compute host or to have very little downtime you need
to use the nova live-migration command.
If you don't want to choose the compute host, or you have a config drive enabled,
you need to use the nova migrate command.
If you need to specify the compute host and you have a config drive enabled, you
need to manually migrate the machine, or use a dirty trick to fool nova migrate.
Hypervisor Capacity
Before you do a migration, check if the hypervisor host has enough free capacity for the
VM you want to migrate:
nova host-describe compute-30

Example output:
+-------------+----------------------------------+-----+-----------+---------+
| HOST | PROJECT | cpu | memory_mb | disk_gb |
+-------------+----------------------------------+-----+-----------+---------+
| compute-30 | (total) | 64 | 512880 | 5928 |
| compute-30 | (used_now) | 44 | 211104 | 892 |
| compute-30 | (used_max) | 44 | 315568 | 1392 |
| compute-30 | 4[...]0288 | 1 | 512 | 20 |
| compute-30 | 4[...]0194 | 20 | 4506 | 62 |
In this table, the first row shows the total amount of resources available on the
physical server. The second line shows the currently used resources. The third line
shows the maximum used resources. The fourth line and below shows the resources
available for each project.
If the VM flavor fits on this hypervisor, continue on with the manual migration. If not,
free up some resources or choose another compute server. If the hypervisor node
lacks enough capacity, the migration will fail.
(Live) migration with nova live-migration
The live-migration command works with the following types of vm's/storage:

 Shared storage: Both hypervisors have access to shared storage.
 Block storage: No shared storage is required. Instances are backed by image
based root disks. Incompatible with read-only devices such as CD-ROMs and
Configuration Drive (config_drive).
 Volume storage: No shared storage is required. Instances are backed by iSCSI
volumes rather than ephemeral disk.
The live-migration command requires the same CPU on both hypervisors. It is

possible to set a generic CPU for the VM's, or a generic set of CPU features. This
however does not work on versions lower than Kilo due to a bug where Nova
compares the actual CPU instead of the virtual CPU. In my case, all the hypervisor
machines are the same, lucky me. This is fixed in Kilo or later.
On versions older than Kilo, the Compute service does not use libvirt's live migration
functionality by default, therefore guests are suspended before migration and might
experience several minutes of downtime. This is because there is a risk that the
migration process will never end. This can happen if the guest operating system
uses blocks on the disk faster than they can be migrated. To enable true live
migration using libvirt's migrate functionality, see the Openstack documentation
linked below.
Shared storage / Volume backed instances

A live-migration is very simple. Use the following command with an instance UUID and
the name of the compute host:
nova live-migration $UUID $COMPUTE-HOST
If you have shared storage, or if the instance is volume backed, this will send the
instances memory (RAM) content over to the destination host. The source hypervisor
keeps track of which memory pages are modified on the source while the transfer is
in progress.
Once the initial bulk transfer is complete, pages changed in the meantime are
transferred again. This is done repeatedly with (ideally) ever smaller increments. As
long as the differences can be transferred faster than the source VM dirties memory
pages, at some point the source VM gets suspended.
Final differences are sent to the target host and an identical machine started there. At
the same time the virtual network infrastructure takes care of all traffic being directed
to the new virtual machine. Once the replacement machine is running, the suspended
source instance is deleted.
Usually the actual handover takes place so quickly and seamlessly that all but very
time sensitive applications ever notice anything. You can check this by starting a ping
to the VM you are live-migrating. It will stay online and when the VM is suspended
and resumed on the target hypervisor, the ping responses will take a bit longer.
Block based storage (--block-migrate)
If we don't have shared storage and the VM is not backed by a volume as root disk
(image based VM's) a live-migration requires an extra parameter: nova live-migration
----block-migrate $UUID $COMPUTE-HOST
The process is almost exactly the same as described above. There is one extra step
however. Before the memory contents is sent the disk content is copied over, without
downtime. When the VM is suspended, both the memory contents and the disk
contents are sent over.
The suspend action takes longer and might be noticeable as downtime. The --block-
migrate option is incompatible with read only devices such as ISO CD/DVD drives
and the Config Drive.
Migration with nova migrate

The nova migrate command shuts down an instance, copies over the disk to a
hypervisor with enough free resources, starts it up there and removes it from the
source hypervisor.
The VM is shut down and will be down as long as the copying. With a migrate, the
Openstack cluster chooses an compute-service enabled hypervisor with the most
resources available. This works with any type of instance, with any type of backend
storage.
A migrate is even simpler than a live-migration. Here's the syntax:
nova migrate $UUID
This is perfect for instances that are part of a clustered service, or when you have
scheduled and communicated downtime for that specific VM. The downtime is
dependent on the size of the disk and the speed of the (storage) network. rsync over
ssh is used to copy the actual disk, you can test the speed yourself with a few regular
rsync tests, and combine that with the disk size to get an indication of the migration
downtime.
Migrating to a specific compute node, the dirty way

We cannot migrate virtual machines to a specific compute node if the compute node
does not have shared storage and the virtual machine has a config drive enabled. We
can force the Openstack cluster to choose a specific hypervisor by disabling the
nova-compute service on all the other hypervisors. The VM's will keep running on
there, only new virtual machines and migrations are not possible on those
hypervisors.
If we have a lot of creating and removing of machines in our Openstack Cloud, this
might be a bad idea. If we use (Anti) Affinity Groups, VM's created there will also fail
to start depending on the type of Affinity Group. Therefore, use this option with
caution. If we have 5 compute nodes, compute-30 to compute-34 and we want to
migrate the machine to compute-34, we need to disable the nova-compute service on
all other hypervisors.
First check the state of the cluster:
nova service-list --binary nova-compute # or nova-conductor, nova-cert,

novaconsoleauth, nova-scheduler
Example output:
+----+--------------+--------------+------+----------+-------+--------------------
--------+-----------------+
| Id | Binary | Host | Zone | Status | State | Updated_at

| Disabled Reason |
+----+--------------+--------------+------+----------+-------+--------------------
--------+-----------------+
| 7 | nova-compute | compute-30 | OS1 | enabled | up | 2015-06-
13T17:04:27.000000 | - |
| 8 | nova-compute | compute-31 | OS2 | enables | up | 2015-06-
13T17:02:49.000000 | - |
13T17:02:50.000000 | None |
13T17:02:50.000000 | - |
| 11 | nova-compute | compute-34 | OS1 | disabled | up | 2015-06-
13T17:02:49.000000 | Migrations Only |
+----+--------------+--------------+------+--------
In the above example, we have 5 compute nodes, of which one is disabled with
reason Migrations Only. In our case, before we started migrating we have enabled
nova compute on that hypervisor and disabled it on all the other hypervisors:
nova service-disable compute-30 nova-compute --reason 'migration to specific

hypervisor the dirty way'
nova service-disable compute-31 nova-compute --reason 'migration to specific
hypervisor the dirty way'
etc...
Now execute the nova migrate command. Since we have disabled all compute
hypervisors except the target hypervisor, that one will be used as migration target. All
new virtual machines created during the migration will also be spawned on that
specific hypervisor. When the migration is finished, enable all the other compute
nodes:
nova service-enable compute-30 nova-compute

nova service-enable compute-31 nova-compute
etc...
In our case, we would disable the compute-34 because it is for migrations only. This
is a bit dirty and might cause problems if you have monitoring on the cluster state or
spawn a lot of machines all the time.
Manual migration to a specific compute node

As seen above, we cannot migrate virtual machines to a specific compute node if the
compute node does not have shared storage and the virtual machine has a config
drive enabled. Since Openstack is just a bunch of wrappers around native Linux
tools, we can manually migrate the machine and update the Nova database
afterwards.
Do note that this part is specific to the storage you use. In this example we use local
storage (or, a local folder on an NFS mount not shared with other compute nodes)
and image-backed instances. In my case, I needed to migrate an image-backed block
storage instance to a non-shared storage node, but the instance had a configdrive
enabled. Disabling the compute service everywhere is not an option, since the cluster
was getting about a hundred new VM's every 5 minutes and that would overload the
hypervisor node.
This example manually migrates a VM from compute-30 to compute-34. These nodes

are in the same network and can access one another via SSH keys based on their
hostname.
Shut down the VM first:

nova stop $VM_UUID
Also detach any volumes:
nova volume-detach $VM_UUID $VOLUME_UUID
Use the nova show command to see the specific hypervisor the VM is running on:
nova show UUID | grep hypervisor
Example output:
| OS-EXT-SRV-ATTR:hypervisor_hostname | compute-30 |
Login to that hypervisor via SSH. Navigate to the folder where this instance is located,
in our case,/var/lib/nova-compute/instances/$UUID.
The instance is booted from an image based root disk, named disk. qemu in our case
diffs the root disk from the image the VM was created from. Therefore the new
hypervisor also needs that backing image. Find out which file is the backing image:
cd /var/lib/nova-compute/instances/UUID/
qemu-img info disk # disk is the filename of the instance root disk
Example output:
image: disk
file format: qcow2
virtual size: 32G (34359738368 bytes)
disk size: 1.3G
cluster_size: 65536
backing file: /var/lib/nova-compute/instances/_base/d00[...]61
Format specific information:

compat: 1.1
lazy refcounts: false
The file /var/lib/novacompute/
instances/_base/d004f7f8d3f79a053fad5f9e54a4aed9e2864561 is the backing disk.
Note that the long filename is not a UUID but a checksum of the specific image version.
In my case it is a raw disk:
qemu-img info /var/lib/nova-compute/instances/_base/d00[...]61

Example output:
image: /var/lib/nova-compute/instances/_base/d00[...]61
file format: raw
virtual size: 8.0G (8589934592 bytes)

disk size: 344M
Check the target hypervisor for the existence of that image. If it is not there, copy that
file to the target hypervisor first:
rsync -r --progress /var/lib/nova-compute/instances/_base/d00[...]61 -e ssh

compute-34:/var/lib/nova-compute/instances/_base/d00[...]61
On the target hypervisor, set the correct permissions:

chown nova:nova /var/lib/nova-compute/instances/_base/d00[...]61
Copy the instance folder to the new hypervisor:
cd /var/lib/nova-compute/instances/
rsync -r --progress $VM_UUID -e ssh compute-34:/var/lib/nova-compute/instances/
Set the correct permissions on the folder on the target hypervisor:
chown nova:nova /var/lib/nova-compute/instances/$VM_UUID
chown nova:nova /var/lib/nova-compute/instances/$VM_UUID/disk.info
chown nova:nova /var/lib/nova-compute/instances/libvirt.xml
chown libvirt:kvm /var/lib/nova-compute/instances/$VM_UUID/console.log
chown libvirt:kvm /var/lib/nova-compute/instances/$VM_UUID/disk
chown libvirt:kvm /var/lib/nova-compute/instances/$VM_UUID/disk.config
If you use other usernames and groups, change those in the command. Log in to
your database server. In my case that is a MySQL Galera cluster. Start up a MySQL
command prompt in the novadatabase
mysql nova
Execute the following command to update the nova database with the new
hypervisor for this VM:
update instances set node='compute-34', host=node where uuid='$VM_UUID';
This was tested on an IceHouse database scheme, other versions might require
other queries. Use the nova show command to see if the new hypervisor is set. If so,
start the VM:
nova start $VM_UUID
Attach any volumes that were detached earlier:
nova volume-attach $VM_UUID $VOLUME_UUID
Use the console to check if it all works:
nova get-vnc-console $VM_UUID novnc
Do note that we must check the free capacity ourself. The VM will work if there is not
enough capacity, but we do run in to weird issues with the hypervisor like bad
performance or killed processes (OOM's).
RESULT:
Thus the virtual machine migration based on the certain condition from one node
to the other was executed successfully.
Ex.No.11. FIND PROCEDURE TO INSTALL STORAGE CONTROLLER AND

INTERACT WITH IT
OBJECTIVE:
To find procedure to install storage controller and interact with it.
PROCEDURE:
OpenStack Block Storage

The OpenStack Block Storage service (cinder) adds persistent storage to a virtual
machine. Block Storage provides an infrastructure for managing volumes, and
interacts with OpenStack Compute to provide volumes for instances. The service also
enables management of volume snapshots, and volume types. The Block Storage
service consists of the following components:
cinder-api
Accepts API requests, and routes them to the cinder-volume for action.
cinder-volume
Interacts directly with the Block Storage service, and processes such as the cinder-
scheduler. It also interacts with these processes through a message queue. The
cinder-volume service responds to read and write requests sent to the Block Storage
service to maintain state. It can interact with a variety of storage providers through a
driver architecture.
cinder-scheduler daemon
Selects the optimal storage provider node on which to create the volume. A similar
component to the nova-scheduler.
Messaging queue
Routes information between the Block Storage processes.
Install and configure controller node

This section describes how to install and configure the Block Storage service, code-
named cinder, on the controller node. This service requires at least one additional
storage node that provides volumes to instances.
To configure prerequisites
Before you install and configure the Block Storage service, you must create a
database, service credentials, and API endpoints.
1. To create the database, complete these steps:
a. Use the database access client to connect to the database server as
the root user:
$ mysql -u root -p
2. Create the cinder database:
CREATE DATABASE cinder;

a. Grant proper access to the cinder database:
GRANT ALL PRIVILEGES ON cinder.* TO 'cinder'@'localhost' \
IDENTIFIED BY 'CINDER_DBPASS';
GRANT ALL PRIVILEGES ON cinder.* TO 'cinder'@'%' \
IDENTIFIED BY 'CINDER_DBPASS';
Replace CINDER_DBPASS with a suitable password.
b. Exit the database access client.
3. Source the admin credentials to gain access to admin-only CLI
commands:
$ source admin-openrc.sh
4. To create the service credentials, complete these steps:
a. Create a cinder user:
$ keystone user-create --name cinder --pass CINDER_PASS
+----------+----------------------------------+
| Property | Value |
+----------+----------------------------------+
| email | |
| enabled | True |
| id | 881ab2de4f7941e79504a759a83308be |
| name | cinder |
| username | cinder |
+----------+----------------------------------+
Replace CINDER_PASS with a suitable password.
b. Add the admin role to the cinder user:
$ keystone user-role-add --user cinder --tenant service --role admin
c. Create the cinder service entities:

$ keystone service-create --name cinder --type volume \
--description "OpenStack Block Storage"
+-------------+----------------------------------+
+-------------+----------------------------------+
| description | OpenStack Block Storage |
| enabled | True |
| id | 1e494c3e22a24baaafcaf777d4d467eb |
| name | cinder |
| type | volume |
+-------------+----------------------------------+
$ keystone service-create --name cinderv2 --type volumev2 \
--description "OpenStack Block Storage"
+-------------+----------------------------------+
+-------------+----------------------------------+
| description | OpenStack Block Storage |
| enabled | True |
| id | 16e038e449c94b40868277f1d801edb5 |
| name | cinderv2 |
| type | volumev2 |
+-------------+----------------------------------+
4. Create the Block Storage service API endpoints:
$ keystone endpoint-create \
--service-id $(keystone service-list | awk '/ volume / {print $2}') \
--publicurl http://controller:8776/v1/%$tenant_id$s \
--internalurl http://controller:8776/v1/%$tenant_id$s \
--adminurl http://controller:8776/v1/%$tenant_id$s \
--region regionOne
+-------------+-----------------------------------------+
+-------------+-----------------------------------------+
| adminurl | http://controller:8776/v1/%(tenant_id)s |
| id | d1b7291a2d794e26963b322c7f2a55a4 |
| internalurl | http://controller:8776/v1/%(tenant_id)s |
| publicurl | http://controller:8776/v1/%(tenant_id)s |
| region | regionOne |
| service_id | 1e494c3e22a24baaafcaf777d4d467eb |
+-------------+-----------------------------------------+
$ keystone endpoint-create \
--service-id $(keystone service-list | awk '/ volumev2 / {print $2}') \
--publicurl http://controller:8776/v2/%$tenant_id$s \
--internalurl http://controller:8776/v2/%$tenant_id$s \
--adminurl http://controller:8776/v2/%$tenant_id$s \
--region regionOne
+-------------+-----------------------------------------+
+-------------+-----------------------------------------+
| adminurl | http://controller:8776/v2/%(tenant_id)s |
| id | 097b4a6fc8ba44b4b10d4822d2d9e076 |
| internalurl | http://controller:8776/v2/%(tenant_id)s |
| publicurl | http://controller:8776/v2/%(tenant_id)s |
| region | regionOne |
| service_id | 16e038e449c94b40868277f1d801edb5 |
+-------------+-----------------------------------------+
To install and configure Block Storage controller components
1. Install the packages:

# apt-get install cinder-api cinder-scheduler python-cinderclient
2. Edit the /etc/cinder/cinder.conf file and complete the following actions:

a. In the [database] section, configure database access:
[database]
...
connection = mysql://cinder:CINDER_DBPASS@controller/cinder
Replace CINDER_DBPASS with the password you chose for the Block Storage
database.
b. In the [DEFAULT] section, configure RabbitMQ message broker access:
[DEFAULT]
...
auth_strategy = keystone
[keystone_authtoken]
...
auth_uri = http://controller:5000/v2.0
identity_uri = http://controller:35357
admin_tenant_name = service
admin_user = cinder
admin_password = CINDER_PASS
3. Replace CINDER_PASS with the password you chose for the cinder user in the
Identity service.
4. In the [DEFAULT] section, configure the my_ip option to use the management
interface IP address of the controller node:
[DEFAULT]
...
my_ip = 10.0.0.11
(Optional) To assist with troubleshooting, enable verbose logging in the [DEFAULT]

section:
[DEFAULT]
...
verbose = True
Populate the Block Storage database:

# su -s /bin/sh -c "cinder-manage db sync" cinder
To finalize installation
1. Restart the Block Storage services:
# service cinder-scheduler restart
# service cinder-api restart
2. By default, the Ubuntu packages create an SQLite database.

Because this configuration uses a SQL database server, you can remove the
SQLite database file:
# rm -f /var/lib/cinder/cinder.sqlite
Install and configure a storage node

This section describes how to install and configure storage nodes for the Block
Storage service. For simplicity, this configuration references one storage node with
an empty local block storage device /dev/sdb that contains a suitable partition table
with one partition /dev/sdb1 occupying the entire device.
The service provisions logical volumes on this device using the LVM driver and
provides them to instances via iSCSI transport. You can follow these instructions
with minor modifications to horizontally scale your environment with additional
storage nodes.
To configure prerequisites
You must configure the storage node before you install and configure the volume
service on it. Similar to the controller node, the storage node contains one network
interface on the management network. The storage node also needs an empty block
storage device of suitable size for your environment.
1. Configure the management interface:

IP address: 10.0.0.41
Network mask: 255.255.255.0 (or /24)
Default gateway: 10.0.0.1
2. Set the hostname of the node to block1.
3. Copy the contents of the /etc/hosts file from the controller node to the storage node
and add the following to it:
# block1
10.0.0.41 block1
Also add this content to the /etc/hosts file on all other nodes in your environment.
4. Install and configure NTP using the instructions in the section called “Other nodes”.
5. Install the LVM packages:
# apt-get install lvm2
Create the LVM physical volume /dev/sdb1:

# pvcreate /dev/sdb1
Physical volume "/dev/sdb1" successfully created.
Create the LVM volume group cinder-volumes:
# vgcreate cinder-volumes /dev/sdb1
Volume group "cinder-volumes" successfully created.
The Block Storage service creates logical volumes in this volume group.
Only instances can access Block Storage volumes. However, the underlying
operating system manages the devices associated with the volumes. By default, the
LVM volume scanning tool scans the /dev directory for block storage devices that
contain volumes. If tenants use LVM on their volumes, the scanning tool detects these
volumes and attempts to cache them which can cause a variety of problems with both
the underlying operating system and tenant volumes. You must reconfigure LVM to
scan only the devices that contain the cinder-volume volume group.
Edit the /etc/lvm/lvm.conf file and complete the following actions:
In the devices section, add a filter that accepts the /dev/sdb device and rejects all
other devices:
devices {
...
filter = [ "a/sdb/", "r/.*/"]
Each item in the filter array begins with a for accept or r for reject and includes a regular
expression for the device name. The array must end with r/.*/ to reject any remaining
devices. You can use the vgs -vvvv command to test filters.
Install and configure Block Storage volume components

1. Install the packages:
# apt-get install cinder-volume python-mysqldb
2. Edit the /etc/cinder/cinder.conf file and complete the following actions:
3. In the [database] section, configure database access:
[database]
...
connection = mysql://cinder:CINDER_DBPASS@controller/cinder
Replace CINDER_DBPASS with the password you chose for the Block Storage
database.
a. In the [DEFAULT] section, configure RabbitMQ message broker access:
[DEFAULT]
...
rpc_backend = rabbit rabbit_host
= controller rabbit_password =
RABBIT_PASS
Replace RABBIT_PASS with the password you chose for the guest account in
RabbitMQ.
c. In the [DEFAULT] and [keystone_authtoken] sections, configure Identity service
access:
[DEFAULT]
...
auth_strategy = keystone
[keystone_authtoken]
...
auth_uri = http://controller:5000/v2.0
identity_uri = http://controller:35357
admin_tenant_name = service
admin_user = cinder
admin_password = CINDER_PASS
Replace CINDER_PASS with the password you chose for the cinder user in the Identity
service.
d. In the [DEFAULT] section, configure the my_ip option:
[DEFAULT]
...
my_ip = MANAGEMENT_INTERFACE_IP_ADDRESS
Replace MANAGEMENT_INTERFACE_IP_ADDRESS with the IP address of the
management
network interface on your storage node, typically 10.0.0.41 for the first node in the
example
architecture.
e. In the [DEFAULT] section, configure the location of the Image Service:
[DEFAULT]
...
glance_host = controller
f. (Optional) To assist with troubleshooting, enable verbose logging in
the [DEFAULT] section:
[DEFAULT]
...
verbose = True
To finalize installation
1. Restart the Block Storage volume service including its dependencies:
# service tgt restart
# service cinder-volume restart
2. By default, the Ubuntu packages create an SQLite database. Because this
configuration uses a SQL
database server, remove the SQLite database file:
# rm -f /var/lib/cinder/cinder.sqlite
Verify operation
This section describes how to verify operation of the Block Storage service by creating a
volume
Source the admin credentials to gain access to admin-only CLI commands:

$ source admin-openrc.sh
2. List service components to verify successful launch of each process:
$ cinder service-list
+------------------+------------+------+---------+-------+-----------------
-----------+-----------------+
| Binary | Host | Zone | Status | State |
Updated_at | Disabled Reason |
+------------------+------------+------+---------+-------+-----------------
-----------+-----------------+
| cinder-scheduler | controller | nova | enabled | up | 2014-10-
18T01:30:54.000000 | None |
| cinder-volume | block1 | nova | enabled | up | 2014-10-
18T01:30:57.000000 | None |
+------------------+------------+------+---------+-------+-----------------
-----------+-----------------+
3. Source the demo tenant credentials to perform the following steps as a
nonadministrative
tenant:
$ source demo-openrc.sh
4. Create a 1 GB volume:
$ cinder create --display-name demo-volume1 1
+---------------------+--------------------------------------+
+---------------------+--------------------------------------+
| attachments | [] |
| availability_zone | nova |
| bootable | false |
| created_at | 2014-10-14T23:11:50.870239 |
| display_description | None |
| display_name | demo-volume1 |
| encrypted | False |
| id | 158bea89-07db-4ac2-8115-66c0d6a4bb48 |
| metadata | {} |
| size | 1 |
| snapshot_id | None |
| source_volid | None |
| status | creating |
| volume_type | None |
+---------------------+--------------------------------------+
5. Verify creation and availability of the volume:
$ cinder list
--------------------------------------+-----------+--------------+------+--
-----------+----------+-------------+
| ID | Status | Display Name | Size |
Volume Type | Bootable | Attached to |
+--------------------------------------+-----------+--------------+------+-
| 158bea89-07db-4ac2-8115-66c0d6a4bb48 | available | demo-volume1 | 1 |

None | false | |
+--------------------------------------+-----------+--------------+------+-
------------+----------+-------------+
Your OpenStack environment now includes Block Storage.
RESULT:
Thus the procedure to install storage controller and interact with openstack service is
executed successfully.
Ex.No.12. FIND PROCEDURE TO SET UP THE ONE NODE HADOOP CLUSTER
OBJECTIVE:
To set up the one node Hadoop cluster.
PROCEDURE:
1) Installing Java
Hadoop is a framework written in Java for running applications on large clusters of
commodity hardware. Hadoop needs Java 6 or above to work.
Step 1: Download tar and extract
Download Jdk tar.gz file for linux-62 bit, extract it into “/usr/local”
# cd /opt
# sudo tar xvpzf /home/itadmin/Downloads/jdk-8u5-linux-x64.tar.gz
# cd /opt/jdk1.8.0_05
Step 2: Set Environments

Open the “/etc/profile” file and Add the following line as per the version.
Set a environment for Java.
Use the root user to save the /etc/proflie or use gedit instead of vi.
The 'profile' file contains commands that ought to be run for login shells.
# sudo vi /etc/profile
#--insert JAVA_HOME
JAVA_HOME=/opt/jdk1.8.0_05
#--in PATH variable just append at the end of the line
PATH=$PATH:$JAVA_HOME/bin
#--Append JAVA_HOME at end of the export statement
export PATH JAVA_HOME
save the file using by pressing “Esc” key followed by :wq!
Step 3: Source the /etc/profile

# source /etc/profile
Step 4: Update the java alternatives

1. By default OS will have a open jdk. Check by “java -version”. You will be prompt
“openJDK”
2. If you also have openjdk installed then you'll need to update the java alternatives:
3. If your system has more than one version of Java, configure which one your system
causes by entering the following command in a terminal window
4. By default OS will have a open jdk. Check by “java -version”. You will be prompt
“JavaHotSpot(TM) 64-Bit Server”
# update-alternatives --install "/usr/bin/java" java "/opt/jdk1.8.0_05/bin/java"
# update-alternatives --config java

--type selection number:
# java –version
configure ssh:
Hadoop requires SSH access to manage its nodes, i.e. remote machines plus your
local machine if you want to use Hadoop on it (which is what we want to do in this
exercise).
For our single-node setup of Hadoop, we therefore need to configure SSH access to
localhost. The need to create a Password-less SSH Key generation based
authentication is so that the master node can then login to slave nodes (and the
secondary node) to start/stop them easily without any delays for authentication.
Generate an SSH key for the user. Then Enable password-less SSH access to sudo
apt-get install openssh-server
--You will be asked to enter password,
root@abc []# ssh localhost
root@abc[]# ssh-keygen
root@abc[]# ssh-copy-id -i localhost
--After above 2 steps, You will be connected without password,
root@abc[]# ssh localhost
root@abc[]# exit
3) Hadoop installation
Now Download Hadoop from the official Apache, preferably a stable release version of
Hadoop 2.7.x and extract the contents of the Hadoop package to a location of your
choice.
For example, choose location as “/opt/”
Step 1: Download the tar.gz file of latest version Hadoop ( hadoop-2.7.x) from the
official site .
Step 2: Extract (untar) the downloaded file from this commands to /opt/bigdata
root@abc[]# cd /opt
root@abc[/opt]# sudo tar xvpzf /home/itadmin/Downloads/hadoop-2.7.0.tar.gz
root@abc[/opt]# cd hadoop-2.7.0/
Like java, update Hadop environment variable in /etc/profile
# sudo vi /etc/profile
#--insert HADOOP_PREFIX
HADOOP_PREFIX=/opt/hadoop-2.7.0
#--in PATH variable just append at the end of the line
PATH=$PATH:$HADOOP_PREFIX/bin
#--Append HADOOP_PREFIX at end of the export statement
export PATH JAVA_HOME HADOOP_PREFIX

save the file using by pressing “Esc” key followed by :wq!
Step 3: Source the /etc/profile
# source /etc/profile
Verify Hadoop installation
# cd $HADOOP_PREFIX
# bin/hadoop version
3.1) Modify the Hadoop Configuration Files

In this section, we will configure the directory where Hadoop will store its configuration
files, the network ports it listens to, etc. Our setup will use Hadoop Distributed File
System,(HDFS), even though we are using only a single local machine.
Add the following properties in the various hadoop configuration files which is available
under $HADOOP_PREFIX/etc/hadoop/core-site.xml, hdfs-site.xml, mapred-site.xml &
yarn-site.xml
Update Java, hadoop path to the Hadoop environment file
# cd $HADOOP_PREFIX/etc/hadoop
# vi hadoop-env.sh
Paste following line at beginning of the file
export JAVA_HOME=/usr/local/jdk1.8.0_05
export HADOOP_PREFIX=/opt/hadoop-2.7.0
Modify the core-site.xml
# cd $HADOOP_PREFIX/etc/hadoop
# vi core-site.xml
Paste following between <configuration> tags
<configuration>
<property>
<name>fs.defaultFS</name>
<value>hdfs://localhost:9000</value>
</property>
< /configuration>
Modify the hdfs-site.xml

# vi hdfs-site.xml
<configuration>
<property>
<name>dfs.replication</name>
<value>1</value>
</property>
</configuration>
YARN configuration - Single Node
modify the mapred-site.xml
# cp mapred-site.xml.template mapred-site.xml
# vi mapred-site.xml
<configuration>
<property>
<name>mapreduce.framework.name</name>
<value>yarn</value>
</property>
</configuration>
Modify yarn-site.xml
# vi yarn-site.xml

<configuration>
<property>
<name>yarn.nodemanager.aux-services</name>
<value>mapreduce_shuffle</value>
</property>
</configuration>
Formatting the HDFS file-system via the NameNode

The first step to starting up your Hadoop installation is formatting the Hadoop files
system which is implemented on top of the local file system of our “cluster” which
includes only our local machine. We need to do this the first time you set up a
Hadoop cluster.
Do not format a running Hadoop file system as you will lose all the data currently in
the cluster (in HDFS)
root@abc[]# cd $HADOOP_PREFIX
root@abc[]# bin/hadoop namenode -format
Start NameNode daemon and DataNode daemon: (port 50070)

root@abc[]# sbin/start-dfs.sh
To know the running daemons jut type jps or /usr/local/jdk1.8.0_05/bin/jps
Start ResourceManager daemon and NodeManager daemon: (port 8088)

root@abc[]# sbin/start-yarn.sh
To stop the running process

root@abc[]# sbin/stop-dfs.sh
To know the running daemons jut type jps or /usr/local/jdk1.8.0_05/bin/jps
Start ResourceManager daemon and NodeManager daemon: (port 8088)

root@abc[]# sbin/stop-yarn.sh
Make the HDFS directories required to execute MapReduce jobs:

$ bin/hdfs dfs -mkdir /user
$ bin/hdfs dfs -mkdir /user/mit
Copy the input files into the distributed filesystem:
$ bin/hdfs dfs -put <input-path>/* /input
Run some of the examples provided:
$ bin/hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.5.1.jar
grep /input /output '(CSE)'
Examine the output files:
Copy the output files from the distributed filesystem to the local filesystem and examine
them:
$ bin/hdfs dfs -get output output
$ cat output/* or
View the output files on the distributed filesystem:
$ bin/hdfs dfs -cat /output/*
RESULT:
Thus setting up of one node Hadoop cluster is successfully executed.
Ex.No.13 MOUNT THE ONE NODE HADOOP CLUSTER USING FUSE
OBJECTIVE:
To mount the one node Hadoop cluster using FUSE.
PROCEDURE:
Hadoop Distributed File System (HDFS) is a distributed, scalable file system

developed as the back-end storage for data-intensive Hadoop applications. As such,
HDFS is designed to handle very large files with "write-once-read-many" access
model.
As HDFS is not a full-fledged POSIX compliant file system, it cannot be directly
mounted by the operating system, and file access with HDFS is done via HDFS shell
commands. However, one can leverage FUSE to write a user land application that
exposes HDFS via a traditional file system interface.
fuse-dfs is one such FUSE-based application which allows you to mount HDFS as if
it were a traditional Linux file system. If you would like to mount HDFS on Linux, you
can install fuse-dfs, along with FUSE as follows. Now, install fuse-dfs and all
necessary dependencies as follows.
To install fuse-dfs on Ubuntu 12.04 and higher:

$ wget http://archive.cloudera.com/one-click-install/maverick/cdh3-
repository_1.0_all.deb
$ sudo dpkg -i cdh3-repository_1.0_all.deb
$ sudo apt-get update
$ sudo apt-get install hadoop-0.20-fuse
Once fuse-dfs is installed, go ahead and mount HDFS using FUSE as follows.
$ sudo hadoop-fuse-dfs dfs://<name_node_hostname>:<namenode_port>
<mount_point>
Once HDFS has been mounted at <mount_point>, you can use most of the traditional
filesystem operations (e.g., cp, rm, cat, mv, mkdir, rmdir, more, scp). However,
random write operations such as rsync, and permission related operations such as
chmod, chown are not supported in FUSE-mounted HDFS.
RESULT:
Thus mounting the one node Hadoop cluster using FUSE is successfully executed.
Ex.No.14 WRITE A PROGRAM TO USE THE API'S OF HADOOP TO INTERACT

WITH IT
OBJECTIVE:
Program to use Hadoop’s File system API'
PROCEDURE:
Reading data from and writing data to Hadoop Distributed File System (HDFS) can be
done in a lot of ways. Now let us start by using the FileSystem API to create and write to
a file in HDFS, followed by an application to read a file from HDFS and write it back to
the local file system.
Step 1: Once you have downloaded a test dataset, we can write an application to
read a file from the local file system and write the contents to Hadoop Distributed
File System.
package com.hadoop.hdfs.writer;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.util.Tool;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.util.ToolRunner;
public class HdfsWriter extends Configured implements Tool {
public static final String FS_PARAM_NAME = "fs.defaultFS";
public int run(String[] args) throws Exception {
if (args.length < 2) {
System.err.println("HdfsWriter [local input path] [hdfs output path]");
return 1;
}
String localInputPath = args[0];
Path outputPath = new Path(args[1]);
Configuration conf = getConf();
System.out.println("configured filesystem = " + conf.get(FS_PARAM_NAME));
FileSystem fs = FileSystem.get(conf);
if (fs.exists(outputPath)) {
System.err.println("output path exists");
return 1;
}
OutputStream os = fs.create(outputPath);
InputStream is = new BufferedInputStream(new FileInputStream(localInputPath));
IOUtils.copyBytes(is, os, conf);

return 0;
}
public static void main( String[] args ) throws Exception {
int returnCode = ToolRunner.run(new HdfsWriter(), args);
System.exit(returnCode);
}
}
Step 2: Export the Jar file and run the code from terminal to write a sample file to
HDFS.
[training@localhost ~]$ hadoop jar HdfsWriter.jar com.hadoop.hdfs.writer.HdfsWriter
sample.txt /user/training/HdfsWriter_sample.txt
Step 3: Verify whether the file is written into HDFS and check the contents of the
file.
[training@localhost ~]$ hadoop fs -cat /user/training/HdfsWriter_sample.txt
Step 4: Next, we write an application to read the file we just created in Hadoop
Distributed File System and write its contents back to the local file system.
package com.hadoop.hdfs.reader;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;
public class HdfsReader extends Configured implements Tool {
public static final String FS_PARAM_NAME = "fs.defaultFS";
public int run(String[ ] args) throws Exception {
if (args.length < 2) {
System.err.println("HdfsReader [hdfs input path] [local output path]");

return 1;
}
Path inputPath = new Path(args[0]);
String localOutputPath = args[1];
Configuration conf = getConf();
System.out.println("configured filesystem = " + conf.get(FS_PARAM_NAME));
FileSystem fs = FileSystem.get(conf);
InputStream is = fs.open(inputPath);
OutputStream os = new BufferedOutputStream(new

FileOutputStream(localOutputPath));
IOUtils.copyBytes(is, os, conf);
return 0;
}
public static void main( String[] args ) throws Exception {
int returnCode = ToolRunner.run(new HdfsReader(), args);
System.exit(returnCode);
}
}
Step 5: Export the Jar file and run the code from terminal to write a sample file to
HDFS.
[training@localhost ~]$ hadoop jar HdfsReader.jar com.hadoop.hdfs.reader.HdfsReader
/user/training/HdfsWriter_sample.txt /home/training/HdfsReader_sample.txt
Step 6: Verify whether the file is written back into local file system.
[training@localhost ~]$ hadoop fs -cat /user/training/HdfsWriter_sample.txt
FileSystem is an abstract class that represents a generic file system. Most Hadoop
file system implementations can be accessed and updated through the FileSystem
object. To create an instance of the HDFS, you call the method FileSystem.get().
The FileSystem.get() method will look at the URI assigned to the fs.defaultFS
parameter of the Hadoop configuration files on your classpath and choose the correct
implementation of the FileSystem class to instantiate. The fs.defaultFS parameter of
HDFS has the value hdfs://.
Once an instance of the FileSystem class has been created, the HdfsWriter class
calls the create() method to create a file in HDFS. The create() method return an
OutputStream object, which can be manipulated using normal Java I/O methods.
Similarly HdfsReader calls the method open() to open a file in HDFS, which returns
an InputStream object that can be used to read the contents of the file. The
FileSystem API is extensive. To demonstrate some of the other methods available in
the API, we can add some error checking to the HdfsWriter and HdfsReader classes
we created.
To check whether the file exists before we call create(), use:

boolean exists = fs.exists(inputPath);
To check whether the path is a file, use:

boolean isFile = fs.isFile(inputPath);
To rename a file that already exits, use:

boolean renamed = fs.rename(inputPath, new Path("old_file.txt"));
RESULT:
Thus the program to use the Hadoop File System API to interact with it is
successfully executed.
Ex.No.15 WRITE A WORDCOUNT PROGRAM TO DEMONSTRATE THE USE OF

MAP AND REDUCE TASKS
OBJECTIVE:
Word count program to demonstrate the use of Map and Reduce tasks.
PROCEDURE:
1. Analyze the input file content

2. Develop the code
a. Writing a map function
b. Writing a reduce function
c. Writing the Driver class
3. Compiling the source
4. Building the JAR file
5. Starting the DFS
6. Creating Input path in HDFS and moving the data into Input path
7. Executing the program
Sample Program:
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.util.GenericOptionsParser;
public class WordCount
{
//Step a
public static class TokenizerMapper extends Mapper < Object , Text, Text, IntWritable >
{
//hadoop supported data types
private final static IntWritable one = new IntWritable(1);
private Text word = new Text();
//map method that performs the tokenizer job and framing the initial key value pairs
public void map( Object key, Text value, Context context) throws IOException ,
InterruptedException
{
//taking one line at a time and tokenizing the same
StringTokenizer itr = new StringTokenizer (value.toString());
//iterating through all the words available in that line and forming the key value pair
while (itr.hasMoreTokens())
{
word.set(itr.nextToken());
//sending to the context which inturn passes the same to reducer
context.write(word, one);
}
}
}
//Step b
public static class IntSumReducer extends Reducer < Text, IntWritable, Text,
IntWritable >
{
private IntWritable result = new IntWritable();
// Reduce method accepts the Key Value pairs from mappers, do the aggregation based
on keys
// and produce the final output
public void reduce(Text key, Iterable < IntWritable > values, Context context) throws
IOException , InterruptedException }
int sum = 0;
/*iterates through all the values available with a key and
add them together and give the final result as the key and sum of its values*/
for (IntWritable val: values)
{
sum += val.get();
} result.set(sum);
context.write(key, result);
}
}
//Step c
public static void main( String [] args) throws Exception
{
//creating conf instance for Job Configuration
Configuration conf = new Configuration();
//Parsing the command line arguments
String [] otherArgs = new GenericOptionsParser(conf,args).getRemainingArgs();
if (otherArgs.length < 2)
{
System .err.println( "Usage: wordcount <in> [<in>...]<out>" );
System .exit(2);
}
//Create a new Job creating a job object and assigning a job name for identification
//purposes
Job job = new Job(conf, "word count" );
job.setJarByClass(WordCount.class);
// Specify various job specific parameters
job.setMapperClass(TokenizerMapper.class);
job.setCombinerClass(IntSumReducer.class);
job.setReducerClass(IntSumReducer.class);
//Setting job object with the Data Type of output Key
job.setOutputKeyClass(Text.class);
//Setting job object with the Data Type of output value
job.setOutputValueClass(IntWritable.class);
//the hdfs input and output directory to be fetched from the command line
for ( int i = 0; i < otherArgs.length 1; ++i)
{
FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
}
FileOutputFormat.setOutputPath(job, new Path(otherArgs[otherArgs.length 1]));
System .exit(job.waitForCompletion( true ) ? 0 : 1);
}
}
Compiling the source:

bigdata@localhost:$ cd /home/bigdata/Downloads/mrcode/src
bigdata@localhost:/home/bigdata/Downloads/mrcode/src$ javac classpath

../lib/hadoopcommon2.5.0.jar:../lib/hadoopmapreduceclientcore2.5.0.jar:../lib/commonscl
i1.2.jar d../build/ bigdata/WordCount.java
Building the JAR File:

bigdata@localhost:/home/bigdata/Downloads/mrcode/src$ cd ../build/
bigdata@localhost:/home/bigdata/Downloads/mrcode/build$ jar cvf wc.jar .
Starting the DFS (if not running already)

bigdata@localhost:/home/bigdata/Downloads/hadoop2.5.1$sbin/startdfs.sh
Creating Input path in HDFS and moving the data into Input path
bigdata@localhost:/home/bigdata/Downloads/hadoop2.5.1$bin/hadoop fs mkdir/mrin
bigdata@localhost:/home/bigdata/Downloads/hadoop2.5.1$bin/hadoop
fs copyFromLocal/home/bigdata/Downloads/mrcode/mrsampledata/*
hdfs://localhost:9000/mrin
Executing the program

bigdata@localhost:/home/bigdata/Downloads/hadoop2.5.1$bin/hadoop jar
/home/bigdata/Downloads/mrcode/build/wc.jar bigdata.WordCount /mrin /mrout1
RESULT:
Thus the Word count program to use Map and reduce tasks is demonstrated
successfully.

Lab Manual

Uploaded by

Copyright:

Available Formats

Lab Manual

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lab Manual

Uploaded by

Copyright:

Available Formats

CS6712 – GRID AND CLOUD COMPUTING LABORATORY

Ex. No.1 Develop a new Web Service for Calculator

To develop a new Web service for Calculator applications.

(a) add, that adds a to the resource property value.

public interface Math {

Step 1 Getting the Files

A Windows zip compressed version can be found at

Deployment Descriptor -- The deployment descriptor gives several different important

Step 2 – Building the Math Service

The output should look similar to the following:

Step 3 – Deploying the Math Service

Successful output of the command is :

Step 4 – Compiling the Client

(a) Settting the Classpath

(b) Compiling Client

Step 5 – Start the Container for your Service

Restart the Globus container from the Container Window with:

Step 6 – Run the Client

The output will be:

Step 7 – Undeploy the Math Service and Kill a Container

which should result with the following output:

Step 8 - Adding Functionality to the Math Service

Ex.No.2. Develop New OGSA-Compliant Web Service

To develop a new OGSA-compliant web service.

1. Define the service's interface. This is done with WSDL.

4. Select the Axis2 Web service facet. Click Finish.

5. This will create a dynamic Web project in the workbench.

testfarenheitToCelsius() -> farenheitToCelsius8.setFarenheit(212);

The Web Service wizard orchestrates the end-to-end generation, assembly,

Thus the development of a new OGSA-compliant web service was executed

Ex.No.3 Using Apache Axis develop a Grid Service

To develop a Grid Service using Apache Axis.

We will need to download and install the following software:

Run the downloaded executable (jakarta-tomcat-4.1.24.exe), and assume the

Start Tomcat by running C:\ jakarta-tomcat-4.1.24\bin\startup.bat and test it by

Set-up your CLASSPATH environment variable to including the following:

5. Deploy a Sample Web service packaged within Axis installations

Ex.No.4 Develop applications using Java or C/C++ Grid APIs

Socket sample code – within some function body

MPI sample code

C/C++ compile.sh – Helloworld.cpp

C/C++ MPI sample code – Helloworld.cpp

Ex.No.5 Develop secured applications using basic security mechanisms

To develop a secured applications using basic security mechanisms available in

WEB SERVICES AUTHENTICATION AND AUTHORIZATION –

A Web services implementation of the Grid Security Infrastructure (GSI),

Pre-requisites for using GAP

Basic Job Submission

Advanced Job Submission

The user is provided with two modes in this interface:

Steps for Reservation of Resources

Steps to be followed to access GSRM from gridfs:

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/gsrm- client/cgsi_soap/lib

Bestman Java APIs

StoRM Command Line Client

Bestman Command Line Clients

Pre-requisites for using SOA compiler

Thus the development of secured applications using basic security mechanisms

2. Java Webstart application