Getting Started Using HBase in Microsoft Azure HDInsight · DBI-IL202 Getting Started Using HBase in Microsoft Azure HDInsight 4 You will be able to query tweets with certain keywords

Getting Started

Using HBase in

Microsoft Azure

HDInsight

Getting Started Using HBase in Microsoft Azure HDInsight

Contents

Overview and Azure account requrements .............. 3

Create an HDInsight cluster for HBase ....................... 5

Create a Twitter application ID ..................................... 9

Configure and run a Twitter streaming service ...... 11

Explore the simple streaming application ............... 17

Explore the web application ........................................ 26

Conclusion .......................................................................... 31

Roll back Azure changes ............................................... 32

Terms of use ...................................................................... 33

DBI-IL202 Getting Started Using HBase in Microsoft Azure HDInsight 3

Estimated time to complete lab is 40-45 minutes.

Overview

Social web sites are one of the major driving forces for Big Data

adoption. Public APIs provided by sites like Twitter are a useful source

of data for analyzing and understanding popular trends. In this tutorial,

you will develop a console streaming service application and an

ASP.NET Web application to perform the following:

Get geo-tagged Tweets in real-time using the Twitter

streaming API.

Evaluate the sentiment of these Tweets.

Store the sentiment information in HBase using the Microsoft

HBase SDK.

Plot the real-time statistical results on Bing maps using an

ASP.NET Web application. A visualization of the tweets will look

something like this:

Overview and Azure account requrements


You will be able to query tweets with certain keywords to get a sense of

the expressed opinion in tweets is positive, negative, or neutral.

In this lab, you will do the following:

1. Create an HDInsight cluster with HBase.

2. Create a Twitter application ID for your Twitter account.

3. Run a simple Twitter streaming service console application to

create an HBase table and add Twitter data with the location

information.

4. Review the simple Twitter streaming service to see how it

works.

5. Review the web application that displays the location tagged

tweets for a search term to see how it works.

6. Run the web application locally.

7. Clean up your Azure environment.

Azure account requirements

While carrying all of the exercises within this hands on lab you will

either be making use of the the Azure Management portal at

https://portal.azure.com/.

To perform this lab, you will require a Microsoft Azure account.

https://portal.azure.com/


If you do not have an Azure account, you can request a free trial

version by going to http://azure.microsoft.com/en-us/pricing/free-

trial/.

Within the one-month trial version, you can perform other SQL Server

2014 hands on labs along with other tutorials available on Azure.

Note, to sign up for a free trial, you will need a mobile device that can

receive text messages and a valid credit card.

Be sure to follow the Roll back Azure changes section at the end of

this exercise after creating the Azure database so that you can make

the most use of your $200 free Azure credit.

In this section, you will create an HDInsight cluster with HBase enabled

for storing the Twitter data.

Connect to SQLONE computer

1. Click on SQL2014DEMO-SQLO… button on right side of the

screen to connect to the SQLONE computer.

Note, if you have a monitor that supports a larger screen

resolution than 1024 x 768, you can change the screen resolution

for the lab to go as high as 1920 x 1080. By going to a higher

screen resolution, it will be easier to use SQL Server

Management Studio.

2. Right click on the desktop and click on Screen resolution.

3. Select 1366 x 786 (a good minimum screen size for using

SSMS) and click OK.

4. Click Keep Changes.

Create an HDInsight cluster for HBase

http://azure.microsoft.com/en-us/pricing/free-trial/

http://azure.microsoft.com/en-us/pricing/free-trial/


5. Resize the client holLaunchPad Online window for the lab to

fit your screen resolution.

6. During the setup you will need to record credentials and server

locations. Open notepad.exe to keep track of information

Create an Azure Storage Account

If you already have a storage account setup, you can use it for your

HDInsight cluster. Otherwise, you can use the instructions in the

following section to create a storage account.

1. Go to your Azure Management Portal.

2. Click on the Storage icon on the left navigation bar.

3. Click + NEW

4. Click QUICK CREATE

5. For URL, use the first 7 characters of your Microsoft ID used for

accessing the Azure account followed by hbase. For example,

hdidemohbase

The storage account name must be unique within Azure, so you

need a way to make a meaningful unique name.

6. Select West US for the LOCATION/AFFINITY GROUP.

You must use the same location that you used for creating the

Azure SQL Database server for the Export feature to work.

7. Select Locally Redundant for the REPLICATION.

Azure supports Geo-Redundant for high availability, but you

don’t need this for the demo.

8. Click the CREATE STORAGE ACCOUNT check mark to create

the account.


Once the storage account is created, proceed to the next step.

Create an HDInsight Cluster

1. Click on HDINSIGHT in the navigation

pane on the left.

2. In the grey options pane at the bottom, click on +NEW then

HBASE


3. Enter in the following information for the cluster:

CLUSTER NAME: <use your storage account> ex.

hdidemohbase

CLUSTER SIZE: 1 data node, this is to save Azure cost for lab

SUBSCRIPTION: <use default>

CONFIRM PASSWORD: Pass@word12

STORAGE ACCOUNT: <use your storage account> ex.

hdidemohbase


4. Click the check in the lower right corner to continue.

It will take approximately 10 minutes to create the cluster, so

now would be a good time to create your Twitter application.

Create a Twitter application ID and secrets

In this section, you will create an application ID and API secrets that will

be used in the streaming application. If you do not have a Twitter

account, you will need to create one at http://twitter.com. This lab

assumes you already have a Twitter account.

The Twitter Streaming APIs use OAuth to authorize requests. The first

step to use OAuth is to create a new application on the Twitter

Developer site.

1. Sign in to https://apps.twitter.com/.

2. Click the Sign up now link if you don't have a Twitter account.

3. Click Create New App.

4. Enter Name, Description, Website. The Website field is not

really used. It doesn't have to be a valid URL. For example:

Name: MyHBaseAPP – note: the name must be unique

Description: <Put in any value>

Website: http://www.MyHBaseAPP.com

Create a Twitter application ID

http://twitter.com/

http://oauth.net/

https://apps.twitter.com/

http://www.myhbaseapp.com/


5. Check Yes, I agree, and then click Create your Twitter

application.

6. Click the Permissions tab. The default permission is Read only.

This is sufficient for this tutorial.

7. Click the API Keys tab.

8. Click Create my access token.

9. Click Test OAuth in the upper right corner of the page.

10. Write down Consumer key, Consumer secret, Access token,

and Access token secret. You will need the values later in the

tutorial.


Configure the simple Twitter streaming service application

In this section you will open the Twitter streaming service Visual Studio

2013 solution and configure the passwords and keys used to connect to

the HDInsight cluster you created along with the Twitter credentials.

1. Open Visual Studio 2013 by clicking on the Visual Studio icon

on the toolbar.

2. On the Start Page, click on tweet-sentiment under Recent

projects.

Configure and run a Twitter streaming service


3. You should see the App.config file opened up in the editor.

If the App.config file is not open, click on the Solution Explorer

and under the SimpleStreamingService project, double-click

App.config to open it up.


4. Within the <appSetting> section of the code, replace the

values with your Twitter API keys and secrets.

5. Using the example below, the settings should be similar to the

image below.


Configure the HDInsight HBase information

1. Right click on the Notepad icon on the taskbar and click

credentials.txt.

2. This file C:\SQLPROGRAMS\E4\GitRemote\tweet-

sentiment\tweet-sentiment\SimpleStreamingService

directory and contains three lines that represents the

credentials needed to connect to your HDInsight HBase cluster.

Replace the selected cluster name with the name of the cluster

you created. For example: hdidemohbase

3. Close the file and save your changes.

Build the SimpleStreamingService project

1. Right click on the SimpleStreamingService project in the

Solution Explorer and click Build.


2. In the Output window, select the text

C:\SQLPROGRAMS\E4\GitRemote\tweet-sentiment\tweet-

sentiment\SimpleStreamingService\bin\Release\Simpl

eStreamingService.exe and copy it to the clipboard.

Make sure your HDInsight cluster is running

1. Go to Internet Explorer and click on HDINSIGHT on the left

navigation pane within the Azure portal. Locate your server and

verify that the STATUS is shown as Running.

If the cluster is not running, please wait for it to complete before

proceeding. Feel free to read ahead to see what’s coming up.

Run the SimpleStreamingSerivce console application


1. Press the Windows key + R to open the Run window and

paste in the program name you just copied.

2. Click OK to run the application. After approximately 30

seconds, you should see the text Table "tweets_by_words"

created. Then, about 15 seconds later, you should see tweet

information scrolling in the console window. Keep the console

window open thru the duration of the lab so that it can

populate the HBase

Let’s now explore the SimpleStreamingService application that is

described in the Azure tutorial at http://azure.microsoft.com/en-

us/documentation/articles/hdinsight-hbase-analyze-twitter-

sentiment/.

http://azure.microsoft.com/en-us/documentation/articles/hdinsight-hbase-analyze-twitter-sentiment/




SDK Refrences

1. The file that defines the Tweeter streaming service class is

HBaseWriter.cs and should already be open in the project. If it is

not, double click on the file in the Solution Explorer to open it

up.

2. The highlighted assembly references support the HBase and

Twitter APIs. In order to add these to a new project, you need

to install two packages: TweetinivAPI and protobuf-net. For a

new project, you would need to perform the following steps –

you don’t need to do steps 3 through 11 for this lab.

3. From the Tools menu, click Nuget Package Manager, and then

click Package Manager Console. The console panel will open at

the bottom of the page.

4. Use the following commands to install the Tweetinvi package,

which is used to access the Twitter API, and the Protobuf-net

package, which is used to serialize and deserialize objects.

NOTE:

The Microsoft HBase SDK Nuget package is not available as of October

15th, 2014. The Github repo is https://github.com/hdinsight/hbase-

sdk-for-net. Until the SDK is available, you must build the dll yourself.

For instructions, see Get started using HBase with Hadoop in

HDInsight.

9. From Solution Explorer, right-click References, and then click

Add Reference.

10. In the left pane, expand Assemblies, and then click

Framework.

Explore the simple streaming application

Install-Package TweetinviAPI

Install-Package protobuf-net

https://www.nuget.org/packages/TweetinviAPI/

https://www.nuget.org/packages/protobuf-net/

https://github.com/hdinsight/hbase-sdk-for-net

https://github.com/hdinsight/hbase-sdk-for-net

http://azure.microsoft.com/en-us/documentation/articles/hdinsight-hbase-get-started/



11. In the right pane, select the checkbox in front of

System.Configuration, and then click OK.

DictionaryItem class

The dictionary class is used to parse the supplied Twitter dictionary

sentiment file with terms that will be used to compare against

incoming tweets.

1. To view the class definition, click on the Class dropdown and

select SimpleStreamingService.DictionaryItem.

2. This class structure is used to parse the sentiment dictionary file.

The data is used to calculate sentiment score for each Tweet.

3. To preview the dictionary file, right click on the Notepad

toolbar button and click dictionary.tsv.


4. The dictionary.tsv file contains the words used for the

comparison as shown below. You can close the file once you

have completed previewing the contents.

5. Switch back to Visual Studio and then search for private void

LoadDictionary(). This method reads the text and loads them

into a Dictionary object used for comparing the tweets.


6. Search for the private int CalcSentimentScore method. This

method performs the dictionary lookup to compute the

sentiment score.


Understanding the HBaseWriter class

The role of the HBaseWriter class is to read in the HDInsight

credentials, create the HBase table, load the dictionary and start

processing the tweets.

1. Scroll up to the top of the HBaseWriter file to review the

HBaseWriter() method.


2. The private void CreateTweetByWordsCells method takes

the incoming tweet, parses the words using the

_punctiationChars and then creates HBase cell values for the

row representing the tweet. See the code below. The

highlighted d: items below represent the HBase columns within

the d ColumnSchema shown above.


private void CreateTweetByWordsCells(CellSet set, ITweet tweet)

{

var words = tweet.Text.ToLower().Split(_punctuationChars);

int sentimentScore = CalcSentimentScore(words);

var word_pairs = words.Take(words.Length - 1)

.Select((word, idx) => string.Format("{0} {1}", word, words[idx +

1]));

var all_words = words.Concat(word_pairs).ToList();

foreach (var word in all_words)

{

var time_index = (ulong.MaxValue -

(ulong)tweet.CreatedAt.ToBinary()).ToString().PadLeft(20) + tweet.IdStr;

var key = word + "_" + time_index;

var row = new CellSet.Row { key = Encoding.UTF8.GetBytes(key) };

var value = new Cell {

column = Encoding.UTF8.GetBytes("d:id_str"),

data = Encoding.UTF8.GetBytes(tweet.IdStr) };

row.values.Add(value);

value = new Cell {

column = Encoding.UTF8.GetBytes("d:lang"),

data = Encoding.UTF8.GetBytes(tweet.Language.ToString()) };


if (tweet.Coordinates != null)

{

var str = tweet.Coordinates.Longitude.ToString() + "," +

tweet.Coordinates.Latitude.ToString();

value = new Cell {

column = Encoding.UTF8.GetBytes("d:coor"),

data = Encoding.UTF8.GetBytes(str) };


}

value = new Cell {

column = Encoding.UTF8.GetBytes("d:sentiment"),

data = Encoding.UTF8.GetBytes(sentimentScore.ToString()) };


set.rows.Add(row);

}

}

7. You can review the rest of the file.

Exploring program.cs

1. Program.cs is the console application that starts the streaming

process using the following assembly references.


2. The Main method reads in the Twitter API settings from

App.config and then runs the Stream_FIlteredStreamExample()

method.

3. The Stream_FilteredStreamExample() method shown below

sets up a tweeter feed with any tweets that have location data

using the Geo.GenerateLocation() method highlighted below.


private static void Stream_FilteredStreamExample()

{

for (; ; )

{

try

{

var hbase = new HBaseWriter();

var stream = Stream.CreateFilteredStream();

var location = Geo.GenerateLocation(-180, -90, 180, 90);

stream.AddLocation(location);

var tweetCount = 0;

var timer = Stopwatch.StartNew();

stream.MatchingTweetReceived += (sender, args) =>

{

tweetCount++;

var tweet = args.Tweet;

hbase.WriteTweet(tweet);

if (timer.ElapsedMilliseconds > 1000)

{

if (tweet.Coordinates != null)

{

Console.WriteLine("{0}: {1} {2}", tweet.Id, tweet.Language.ToString(),

tweet.Text);

Console.WriteLine("\tLocation: {0}, {1}", tweet.Coordinates.Longitude,

tweet.Coordinates.Latitude);

}

timer.Restart();

Console.WriteLine("===== Tweets/sec: {0} =====", tweetCount);

tweetCount = 0;

}

/*IEnumerable<ILocation> matchingLocations = args.Tweet.;

foreach (var matchingLocation in matchingLocations)

{

Console.Write("({0}, {1}) ;", matchingLocation.Coordinate1.Latitude,

matchingLocation.Coordinate1.Longitude);

Console.WriteLine("({0}, {1})", matchingLocation.Coordinate2.Latitude,

matchingLocation.Coordinate2.Longitude);

}*/

};

stream.StartStreamMatchingAllConditions();

}

catch (Exception ex)

{

Console.WriteLine("Exception: {0}", ex.Message);

}


}

}

4. The stream.matchingTweetReceived line reads the tweet,

performs the sentiment lookup and then returns the HBase

columns as args. The hbase.WriteTweet command then writes

the tweet to the HBase table. This process continues until you

close the console window.

Setting up credentials to run the web application

The web application needs the credentials to the HDInsight cluster so it

can access the data in the HBase table.

1. Click on the Web.config tab in the Visual Studio editor. If it is

not already open, you can double click on the Web.config file

under the WebApp project.

2. Change the Cluster and Pwd keys under the appSettings to

specify your HDInsight cluster as shown below. Leave the User

key as admin.

Explore the web application


Debug the web application

Let’s test run the web application so that you can see it in action and

then walk through the key elements of the program.

1. You should have enough data from Twitter loading into your

HBase table. Go ahead and close the console window.

2. Go back to Visual Studio, right click on the WebApp project in

the Solution Explorer and click Debug > Start new instance.

3. You should see Internet Explorer open against your localhost

with a Bing map in the client region.


4. Change the search term to love and click Go. Then, click on the

Positive, Neutral and Negative buttons to see the total

number of tweets along with the Positive/Negative Ratio.

5. After trying a few other terms, you can close the browser

window to exit the debug process.

About the WebApp ASP.NET MVC Web application

The WebApp was created using an ASP.NET MVC Web application to

read the real-time sentiment data from HBase and plot the data on

Bing maps.

If you wanted to create a new application from scratch, you would

perform the following steps to get started. You do not need to perform

these steps for the lab.


1. Open Visual Studio.

2. Click File, click New, and then click Project.

3. Type or enter the following:

o Template category: Visual C#/Web

o Template: ASP.NET Web Application

o Name: TweetSentimentWeb

o Location: C:\Tutorials

4. Click OK.

5. In Select a template, click MVC.

6. In Windows Azure, click Manage Subscriptions.

7. From Manage Windows Azure Subscriptions, click Sign in.

8. Enter your Azure credential. Your Azure subscription

information will be shown on the Accounts tab.

9. Click Close to close the Manage Windows Azure Subscriptions

window.

10. From New ASP.NET Project - TweetSentimentWeb, Click OK.

11. From Configure Windows Azure Site Settings, select the Region

that is closer to you. You don't need to specify a database

server.

12. Click OK.

13. From the Tools menu, click Nuget Package Manager, and then

click Package Manager Console. The console panel is opened at

the bottom of the page.

14. Use the following command to install the Protobuf-net

package, which is used to serialize and deserialize objects.

Programs, classes and methods of interest

1. Under the WebApp, expand the Models folder and click on

HbaseReader.cs to open it. This program sets up the

connection to the HDInsight HBase table and then searches by

Install-Package protobuf-net


the keyword to return the d:coor and d:sentiment values for

displaying on the Bing map.

public async Task<IEnumerable<Tweet>> QueryTweetsByKeywordAsync(string keyword)

{

var list = new List<Tweet>();

var time_index = (ulong.MaxValue -

(ulong)DateTime.UtcNow.Subtract(new TimeSpan(6, 0,

0)).ToBinary()).ToString().PadLeft(20);

var startRow = keyword + "_" + time_index;

var endRow = keyword + "|";

var scanSettings = new Scanner {

batch = 100000,

startRow = Encoding.UTF8.GetBytes(startRow),

endRow = Encoding.UTF8.GetBytes(endRow) };

ScannerInformation scannerInfo =

await client.CreateScannerAsync(tableByWordsName, scanSettings);

CellSet next;

while ((next = await client.ScannerGetNextAsync(scannerInfo)) != null)

{

foreach (CellSet.Row row in next.rows)

{

var coordinates =

row.values.Find(c => Encoding.UTF8.GetString(c.column) == "d:coor");

if (coordinates != null)

{

var lonlat = Encoding.UTF8.GetString(coordinates.data).Split(',');

var sentimentField =

row.values.Find(c => Encoding.UTF8.GetString(c.column) == "d:sentiment");

var sentiment = 0;

if (sentimentField != null)

{

sentiment = Convert.ToInt32(Encoding.UTF8.GetString(sentimentField.data));

}

list.Add(new Tweet {

Longtitude = Convert.ToDouble(lonlat[0]),

Latitude = Convert.ToDouble(lonlat[1]),

Sentiment = sentiment

});

}

if (coordinates != null)

{

var lonlat = Encoding.UTF8.GetString(coordinates.data).Split(',');

}

}

}


return list;

}

2. Under the WebApp project, expand the Controllers folder and

click on TweetsController.cs file to view it. This is the main

program that will sets up the HBase reader and performs the

query.

3. Expand the Scripts folder and click on the headmap.js file. The

code was written by Alastair Aitchison to display heat map

information using Bing. For more information, see

http://alastaira.wordpress.com/2011/04/15/bing-maps-ajax-v7-

heatmap-library/.

4. Under the Scripts folder, click on the twitterStream.js file. This

script initializes the Bing map and plots the tweets from HBase

as a heat map.

5. Expand the Views and Shared folders and click on the

_Layout.cshtml file. This file sets up the navigation bar for the

web site.

6. Expand the Views and Home folder and click on the

Index.cshtml file. This sets up the title for the page that is

displayed in the IE tab.

7. Expand the Content folder and click on the Site.css file. This

sets up the page to display the Bing map within the sized

browser window.

8. Under the WebApp folder, click on the Global.aspx file. This is

the main application file which registers the API routes to make

Web API controller work inside of the MVC application.

In this lab, you learned how to:

Create an Azure storage account and HDInsight HBase cluster

to store Twitter search results.

Create an application to read in the streaming tweets, score the

sentiment of the tweet based on a dictionary lookup of the

words in the tweet, and write the results to an HBase table.

Create an ASP.NET MVC Web application to read the real-time

sentiment data from HBase and plot the data on Bing maps.

Optionally, you can deploy the application to an Azure Web site. For

instructions, see Get started with Azure Web Sites and ASP.NET.

Conclusion

http://alastaira.wordpress.com/2011/04/15/bing-maps-ajax-v7-heatmap-library/

http://alastaira.wordpress.com/2011/04/15/bing-maps-ajax-v7-heatmap-library/

http://azure.microsoft.com/en-us/documentation/articles/web-sites-dotnet-get-started/


To learn more about HBase on Azure, see Get started using HBase with

Hadoop in HDInsight tutorial.

Let’s clean up the assets we have used during this hands on lab. Here

are the items which should be deleted from your subscription:

Delete the HDInsight cluster

1. Go to the Azure Portal

2. Click on the HDINSIGHT tab on the left hand side

3. Click on the cluster name you used for this lab to display the

cluster getting started page.

4. Click on the DELETE command and then click YES to confirm.

Delete the storage account

This is the storage account created for the HDInsight cluster. For

example: hdidemohbase. Delete it following these steps.

Roll back Azure changes




1. Select the Storage tab on the left hand side

2. Click anywhere in the row of the storage, except within the

name cell as this will navigate into the account

3. Click Delete

4. Confirm the storage account match the one created within this

hands on lab by clicking Yes

© 2014 Microsoft Corporation. All rights reserved.

By using this Hands-on Lab, you agree to the following terms:

The technology/functionality described in this Hands-on Lab is

provided by Microsoft Corporation in a “sandbox” testing environment

for purposes of obtaining your feedback and to provide you with a

learning experience. You may only use the Hands-on Lab to evaluate

such technology features and functionality and provide feedback to

Microsoft. You may not use it for any other purpose. You may not

modify, copy, distribute, transmit, display, perform, reproduce, publish,

license, create derivative works from, transfer, or sell this Hands-on Lab

or any portion thereof.

COPYING OR REPRODUCTION OF THE HANDS-ON LAB (OR ANY

PORTION OF IT) TO ANY OTHER SERVER OR LOCATION FOR FURTHER

REPRODUCTION OR REDISTRIBUTION IS EXPRESSLY PROHIBITED.

THIS HANDS-ONLAB PROVIDES CERTAIN SOFTWARE

TECHNOLOGY/PRODUCT FEATURES AND FUNCTIONALITY,

INCLUDING POTENTIAL NEW FEATURES AND CONCEPTS, IN A

SIMULATED ENVIRONMENT WITHOUT COMPLEX SET-UP OR

INSTALLATION FOR THE PURPOSE DESCRIBED ABOVE. THE

TECHNOLOGY/CONCEPTS REPRESENTED IN THIS HANDS-ON LAB

MAY NOT REPRESENT FULL FEATURE FUNCTIONALITY AND MAY NOT

Terms of use


WORK THE WAY A FINAL VERSION MAY WORK. WE ALSO MAY NOT

RELEASE A FINAL VERSION OF SUCH FEATURES OR CONCEPTS. YOUR

EXPERIENCE WITH USING SUCH FEATURES AND FUNCITONALITY IN A

PHYSICAL ENVIRONMENT MAY ALSO BE DIFFERENT.

FEEDBACK. If you give feedback about the technology features,

functionality and/or concepts described in this Hands-on Lab to

Microsoft, you give to Microsoft, without charge, the right to use, share

and commercialize your feedback in any way and for any purpose. You

also give to third parties, without charge, any patent rights needed for

their products, technologies and services to use or interface with any

specific parts of a Microsoft software or service that includes the

feedback. You will not give feedback that is subject to a license that

requires Microsoft to license its software or documentation to third

parties because we include your feedback in them. These rights survive

this agreement.

MICROSOFT CORPORATION HEREBY DISCLAIMS ALL WARRANTIES

AND CONDITIONS WITH REGARD TO THE HANDS-ON LAB ,

INCLUDING ALL WARRANTIES AND CONDITIONS OF

MERCHANTABILITY, WHETHER EXPRESS, IMPLIED OR STATUTORY,

FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-

INFRINGEMENT. MICROSOFT DOES NOT MAKE ANY ASSURANCES OR

REPRESENTATIONS WITH REGARD TO THE ACCURACY OF THE

RESULTS, OUTPUT THAT DERIVES FROM USE OF THE VIRTUAL LAB, OR

SUITABILITY OF THE INFORMATION CONTAINED IN THE VIRTUAL LAB

FOR ANY PURPOSE.

DISCLAIMER

This lab contains only a portion of new features and enhancements in

Microsoft SQL Server 2014. Some of the features might change in

future releases of the product. In this lab, you will learn about some,

but not all, new features.

Documents

Getting Started Using HBase in Microsoft Azure HDInsight · DBI-IL202 Getting Started Using HBase in Microsoft Azure HDInsight 4 You will be able to query tweets with certain keywords