Transform your business with cutting-edge data analytics from Data Culture, a leading data strategy consulting firm based in Brooklyn, New York. We help by providing data solutions to drive valuable insights into your organization.

Data Culture

Data-driven innovations is the future Harness Data to build customer centric products and leverage its intelligence to make product experience better. Services Data Science And Machine Learning Convert patterns of data into usable inferences by feeding machines with algorithms and data sets ...

Home - Data-Cult

Data Culture is based out of Brooklyn, NY, and serves as a trusted partner for businesses seeking innovative data analytics solutions. Our team of experts is dedicated to delivering value to our clients through cutting-edge technology and industry best practices.

About

We are confident that under her guidance, Data Culture will reach new heights.&quot; For more information reach out to hello@datacult.com. #dataculture #dataanalytics #dataleadership #marketinganalytics #productanalytics #data #b2bdata #salesanalytics #retailanalytics #womenindata #womeninleadership

Data Culture | LinkedIn

Data Cult | 1,185 followers on LinkedIn. Trusted partner to simplify your decision making | On a mission to help 100+ high ambitious startups and organizations transform their business into a data-driven organization, one company at a time. We are aiming to serve businesses like SaaS, Marketing ...

Data Cult | LinkedIn

Low or no-score customers are in a vicious circle; lack of data, credible documentation and assets that may be collateralized, this segment struggles to receive formal credit. If there were any credible data available, Financial institutions may have already offered relevant products, Datacultr ...

Datacultr: Digital Debt Collection Platform with Risk Management

Maximize your business potential with comprehensive data analytics services from Data Culture, a Brooklyn-based consulting firm. Our solutions include data visualization, business intelligence, data modeling, and machine learning to help you make data-driven decisions.

Services

Datacultr is a global Digital Operating System for Credit Recovery, it drives collection efficiencies and reduces delinquencies and NPLs. Datacultr is a digital-only provider of consumer engagement, recovery and collection solutions, helping consumer lending, retail, telecom and Fintech ...

Datacultr | LinkedIn

Datacultr may be growing as indicated by the expansion of its operations to new regions. The company has expanded its footprints to LATAM and Africa, which suggests an increase in its global presence and potential market reach. Additionally, Datacultr&#x27;s involvement in the risk management stack ...

Datacultr - Crunchbase Company Profile & Funding

PitchBook’s non-financial metrics help you gauge a company’s traction and growth using web presence and social reach. Request a free trial · To view Datacultr’s complete investors history, request access »

Datacultr Company Profile: Valuation & Investors | PitchBook

Data Culture helps organizations in solving problems using data and build a lasting data culture.

Data Culture - Crunchbase Company Profile & Funding

Datacultr’s vision is to enable convenient financing opportunities for consumers, entrepreneurs and small merchants, helping them combat the Socioeconomic problems this segment faces from restricted access to financing.

About Datacultr

It&#x27;s our business to grow yours! Own your market with leading B2B contact data combined with sales intelligence, engagement software, and workflow tools.

ZoomInfo: B2B Database | Company Contacts & Intelligence

Transform your data into stunning visual stories with Data Culture Studio. Our creative agency combines design, data visualization, and narrative to help businesses communicate their insights in a compelling way.

Data Culture Studio

As businesses increasingly leverage data-driven decision making, the ability to use and understand data at the company-wide level becomes mission critical. While tech behemoths like Netflix, Airbnb, and Spotify have strong data cultures, startups often face challenges getting up and running ...

Style Guide

View details of Datacultr funding rounds and investors ... Neel Juriasingani, Co-Founder &amp; CEO, is a founder of 2 companies and on the board of 2 companies. 1 email.

Datacultr - Company Profile - Tracxn

We offer B2B data services from mining to engineering/architecture to analytics and ML/AI services solely for the purpose of helping businesses drive their decisions with data

DataCult

The fight for data ownership in Web2 is one that has frequently graced the headlines over the last few years, highlighting the perversion of the original egalitarian intentions of the world wide web. One of the main benefits of the rise of Web3 is the individual’s ability to reclaim ownership over his/her data. This contrasts heavily to the current state of Web2 where large central players own a majority of the data and either use that data to lock users into enclosed ecosystems or sell it to entities targeting ads to their users. Users of Web2 have little choice besides relinquishing ownership of their data in Web2 unless they want to avoid using these services, and as prolific as these services are in Web2, this is nearly impossible. Thus, most users in Web2 willingly give up ownership of their data and privacy in exchange for permission to use these services. Most people are aware of this irresponsible use of their data when, after visiting a product site a single time, they are greeted with ads for those products for the next few weeks on platforms like Facebook or Instagram. This is why many services are “free”, but as the saying goes, “if it’s free, then YOU are the product.” The reason why relinquishing ownership of data is used in exchange for access to many services on Web2 is that data is extremely valuable. Advertising revenue is the life-blood of Web2: from Google, Twitter, Facebook, and other major players, ad revenue makes up a significant portion of their total revenue generated. In Contrast with Web3, blockchains allow users to reclaim ownership over their data and gives them the choice to sell that data in a marketplace or keep it private. As blockchains continue to enable users to maintain control over their data, there have been many players popping up who are building the infrastructure through which data can be more easily transferred in Web3 such as Chainlink and Ocean Protocol. A rising star in this space is The Graph as they’ve aptly named themselves “The Google of Blockchains.” Web3 Before The Graph In order to fully understand The Graph — and its parallels to Google in Web2 — it may be helpful to first understand its core use case in the simplest sense. The Graph is the first Web3 solution to provide a decentralized indexing service for dApps to more easily query data on Layer-1 protocols such as Ethereum and IPFS. Similar to the way an index or a table of contents provides easy searching in a dictionary, legacy databases index all of the data that exists in the database so it is easy for a developer to find the data they are looking for. Anyone who has worked with data in a legacy database can tell you about the ease of running a SQL query to these indexes and retrieving data much faster than if they were scouring the database line by line for the information they were looking for. The same thing happens in Web3. Before The Graph, dApp developers who needed access to data on the blockchain would have to scour the protocol block by block to find the data they were looking for, and as you can imagine, this did not create a good user experience as query times were nowhere near feasible. The only option dApp developers had before The Graph was to index the data themselves so they could more easily query the data, an undertaking that was incredibly labor-intensive for any single dApp being developed and oftentimes prohibitive. The founders of The Graph felt that same frustration when attempting to create their own Ethereum dApps, and in late 2017, they sought to solve this problem for all dApp developers with an ethos that resonates with all players in this space: a fully decentralized protocol. There are already well-known centralized solutions out there like Etherscan that provide a similar service, however, as with any other centralized solution, this is a completely trust-dependent relationship and a single point of failure. With the amount of money on the line in spaces like DeFi and NFTs, this centralization is a deal-breaker for most dApp developers and their users. After all, any dApp is only as strong as its weakest link and if the data fed to users is from a centralized source, the value from any other decentralization is reduced. Comparing The Graph to Web2 Solutions As stated above, the team at Edge & Node (the creators of The Graph) have marketed the protocol as “The Google of Blockchains.” Similar to how Google allows any user to query information that is indexed by Google in Web2, the Graph allows users (via dApp interfaces) to query any information that is indexed from blockchains such as Ethereum and IPFS. Aside from decentralization, there are key differences between Google and The Graph that will help clarify The Graph’s role in Web3. For example, let’s say a developer creates a dApp that aggregates data such as liquidity and trading volume for all token pairs from multiple DeFi dApps like UniSwap and Compound and displays it all in one interface for the user. This dApp developer will want to make sure he/she is providing recent and verifiably accurate data from each of these DeFi applications so his/her users can make better financial decisions. This dApp can then send out an API call to Indexers in the UniSwap and Compound subgraphs (think of subgraphs as separate indexes in different books), Indexers send the information queried back to the dApp, and the dApp pays a fee in GRT (The Graph’s native utility token) for the service. The user never interacts with The Graph directly. While Google allows users to directly query any data on the surface web (as opposed to the deep web), The Graph enables users to do the same to all data indexed on blockchains like Ethereum and IPFS through interfaces offered by dApps. The Data Highway in Web3 Over the past few months, The Graph has quickly gained a cult following similar to the devoted community behind Chainlink, and it makes sense why people are so excited. Chainlink is a data on-ramp — it takes off-chain data and securely sends that data to the blockchain which is verified for accuracy through a decentralized network of nodes. The Graph is a data off-ramp — it pulls on-chain data off of the blockchain and indexes it, allowing dApps to more easily find and receive the data they’re looking to display to their users. This data will provide the Web3 ecosystem the ability to make better decisions: Chainlink provides smart contracts with the data to determine the correct outcome and The Graph provides users with secure data from blockchains in order to make better decisions. Aside from being two sides of the same coin, The Graph is also positioning itself well as a first mover and adopting Chainlink’s future-proofing strategy through . multi-chain support Rapid growth in query volumes shows that The Graph has successfully found a market for the data off-ramp use case. In June 2020, The Graph celebrated its first time crossing . 1 billion monthly queries In April 2021, less than one year later, they crossed the . It should be no surprise that a significant portion of this growth is from the DeFi space. As of July 2020, 76% of all-time query volume was for DeFi use cases. 20 billion monthly queries milestone While all verticals have seen growth in query volume since July 2020, DeFi’s percentage of query volume has taken off. Data from January to March 2021 show that query volume has grown to 90% DeFi use cases. Automated Market Makers (AMM) like Uniswap make up the vast majority of DeFi query volume (88%) but new demand from use cases like derivatives markets and insurance are indications that the DeFi landscape is maturing. While The Graph has seen a lot of success querying data for DeFi use cases, other markets like NFTs and DAOs are fast-growing categories in terms of query volume. Looking Ahead One can’t help but compare the recent growth in queries on The Graph to the . Between 1999 and 2001, Google was seeing year-over-year (YoY) growth rates between 200% and 1000%. early days of Google Between July 2020 and April 2021, The Graph hit 20x in query volume growth by hitting 20 billion monthly queries for the first time. Comparing the timeline of The Graph to the early days of Google and the state of Web2 and Web3 at their respective times, we are potentially witnessing a foreshadowing of continued exponential growth that may eventually rival the volume Google sees today. The beautiful thing about analyzing the growth of The Graph ecosystem is not only seeing the clear need for its services, but also getting a glimpse into the macro shift in trends in the entire Web3 ecosystem. As dApp developers continue to adopt The Graph as their primary blockchain data feed and as The Graph continues to add subgraphs in verticals like DeFi, NFTs, and DAOs, it will act as Web3’s version of Google analytics and will provide additional value to investors and developers alike who are trying to capitalize early on macro trends. All in all, the future looks bright for The Graph as its role in the Web3 data economy grows. What’s great to see is not only the success the protocol has seen, but the founding team’s adamant attitude of progressive decentralization of the network. They’ve backed this ethos since the mainnet went live in December 2020 with the migration of subgraphs and from the hosted service to the mainnet. most recently introducing curators and subgraph development They recognize the commitment to decentralization results in a slower development pace to traditional software development, but too often the blockchain space has seen projects that have in the name of scalability and low transaction fees. sacrificed this principle Considering that only about , The Graph has a lot of room to grow in emerging markets that more easily understand the merits of data ownership and decentralized control. 65% of the world population currently has internet access With ambitious projects like Starlink aiming to provide internet access across the globe to anyone with a smartphone, the total addressable market for The Graph to enable dApps built in these new markets makes it a strong candidate as the go-to protocol providing the majority of data requested by users on the planet.

The Graph and Web3 Take On Google and Web2: The Impending Data Economy Wars

The essence of the pattern is that it creates a centralized bus through which components can send and receive messages (events). The bus acts as a mediator between the components, and they can exchange messages without the need for explicit coupling with each other. Hello everyone, my name is Dmitrii Ivashchenko, and I’m a Software Engineer at MY.GAMES. In this article, we’ll talk about an enum-based event bus in Unity, which we’ll get to in just a moment. Back to the event bus pattern itself, there are several ways to implement this, but the general idea remains the same: components send messages (events) to the bus, and other components subscribe to these events and receive them. There are two main methods to implement an event system: and : Subscribe Raise // At the point where the event occurs, we call Raise
// with the event type and data
EventBus.Raise(some_event_type, arguments);

// In the handler, we subscribe to a specific type
// of events and call the OnSomeEventRaised method
EventBus.Subscribe(some_event_type, OnSomeEventRaised); Often the event type is set as a string, but there are also implementations where a class for the passed data is used as the event type: public struct BuyEvent 
{
 public int ItedId;
}

// Raising a new event
EventBus.Raise<BuyEvent>(new BuyEvent{ ItemId = 1 });

// Subscription to event
EventBus.Subscribe<BuyEvent>(OnPlayerBuy); There are also more interesting implementations where interfaces are used for subscription. The event bus can be shared across the entire code, but there may also be separate buses that differ in purpose and method of message delivery. Another interesting way to implement EventBus is Enum-based. Why enums? Using enums as event types has several advantages: Improved code readability Low overhead for Enum processing Code autocompletion in IDE, with ease of adding new types Eliminated possibility of incorrect spelling, which is the case when using strings It adds the possibility of adding extension methods to extend functionality To more easily illustrate the main principle, some details have been omitted in the code examples below. We’ll also be using the class from the library to transmit events. Instead of UniRx, any other means of storing message handlers could also be used, such as C# delegates and events. ReactiveCommand UniRx . The complete source code is available on GitHub Using an Enum as a Event Bus One way to view an is as a type of data bus, with its elements representing concrete types of events delivered by this bus: Enum // Event bus for user interface-generated events
public enum UiEvent
{
 // Event on clicking on the "buy" button 
 BuyButtonClicked,

		// Event on opening an in-game window
		ScreenOpened,

		// Event on completing the tutorial
		TutorialFinished,

 ...
} Using C# extension methods, we can add methods for sending and subscribing to events to this enum: public static class UiEventExtensions
{
 // Declare a static readonly ReactiveCommand of type UiEvent
 private static readonly ReactiveCommand<UiEvent> 
 _uiEventCommand = new ReactiveCommand<UiEvent>();
 
 // Extension method to raise a UiEvent
 public static void Raise(this UiEvent evnt)
 {
 // Execute the ReactiveCommand with the UiEvent
 _uiEventCommand.Execute(evnt);
 }
 
 // Extension method to subscribe to a UiEvent
 public static IDisposable Subscribe(this UiEvent evntType, Action action)
 {
 // Return a subscription to the ReactiveCommand, 
 // filtered by the UiEvent type
 return _uiEventCommand.Where(evnt => evnt == evntType)
 .Subscribe(evnt => action());
 }
} Now, we can send and receive events in the game logic like so: // Raise the BuyButtonClicked event
**UiEvent.BuyButtonClicked.Raise();**

// Subscribe to the BuyButtonClicked event
var disposable = **UiEvent.BuyButtonClicked.Subscribe**(OnBuyButtonClicked);

// ...

// Unsubscribe from the event
disposable.Dispose(); To pass parameters together with an event, we’ll need an additional class that will store the event type and data. Example implementation: // This class is used to store information about a UI event
public class UiEventParam
{
 // The type of the UI event
 public UiEvent Type { get; }

 // Constructor that sets the type of the UI event
 protected UiEventParam(UiEvent type) => Type = type;

 // Get the data associated with the UI event
 public T Get<T>() => ((UiEventParam<T>) this).Data;
}

// This class is used to store data associated with a UI event
public class UiEventParam<T> : UiEventParam
{
 // The data associated with the UI event
 public readonly T Data;

 // Constructor that sets the type and data of the UI event
 public UiEventParam(UiEvent type, T data) : base(type) => Data = data;
}

public static class UiEventExtensions
{
 // Declare a static readonly ReactiveCommand of type UiEventParam
 private static readonly ReactiveCommand<UiEventParam> _uiEventParam = new ReactiveCommand<UiEventParam>();
 
 // Create a method to raise an event with a generic type
 public static void Raise<T>(this UiEvent evnt, T data) 
 // Execute the ReactiveCommand with a new UiEventParam object containing the event and data
 => _uiEventParam.Execute(new UiEventParam<T>(evnt, data));
 
 // Create a method to subscribe to an event with a generic type
 public static IDisposable Subscribe<T>(this UiEvent evntType, Action<T> action)
 {
 // Return a subscription to the ReactiveCommand, filtering for the specified event type
 return _uiEventParam
 .Where(evnt => evnt.Type == evntType)
 .Subscribe(evnt =>
 // Execute the action with the data from the UiEventParam object
 action(evnt.Get<T>()));
 }

 public static IObservable<T> Where<T>(this UiEvent evntType, Func<T, bool> predicate)
 {
 // Create an observable sequence from the UiEventParam
 var observable = _uiEventParam.Where(evnt =>
 // Check if the event type matches the given event type 
 // and the predicate returns true
 evnt.Type == evntType && predicate(evnt.Get<T>()));
 
 return observable.Select(evnt => evnt.Get<T>());
 }
} In the example above, we created the class for generalized access to the field of the class, and we also added the method that allows filtering events based on the passed data. With these changes, we can further expand the possibilities of using the event bus: UiEventParam Data UiEventParam<T> Where void ExampleOfRaising()
{
 // Raise the SetSoundVolume event with a value
 **UiEvent.SetSoundVolume.Raise(0.5f);**
}

void SubscribeOnEvents()
{
 _disposable = new CompositeDisposable
 {
 // Subscribe to the SetSoundVolume event with any value
 **UiEvent.SetSoundVolume.Subscribe<float>(OnSetVolume),**
 
 // Subscribe to the SetSoundVolume event
 // and call the OnMute method when it is raised with a value of 0f
 **UiEvent.SetSoundVolume.Where<float>(x => x == 0f).Subscribe(OnMute),**
 };
} Encapsulating network events in an enum-based bus Similarly, we can wrap any network interactions in an enum-extension, whether that’s message exchange with the backend, or anything else. Let's consider the example of the network library . We'll write a C# extension that wraps the receiving and sending of events in an enum called : Photon Unity Networking 2 NetEvent public static class NetEventExtensions
{
 // Create a new ReactiveCommand of type NetEventParam
 private static readonly ReactiveCommand<NetEventParam> 
 _netEventParam = new ReactiveCommand<NetEventParam>();

 // Extension method to raise a NetEvent with data
 public static void Raise<T>(this NetEvent evnt, T data)
 {
 // Raise the event with the data, options, and reliable send
 PhotonNetwork.RaiseEvent((byte) evnt, data, GetOptions(evnt), SendOptions.SendReliable);
 }

 // Extension method to subscribe to a NetEvent
 public static IDisposable Subscribe<T>(this NetEvent evntType, Action<T> action)
 {
 // Return a subscription to the ReactiveCommand, 
 // filtered by the event type, 
 // and call the action with the data
 return _netEventParam.Where(evnt => evnt.Type == evntType)
 .Subscribe(evnt => action(evnt.Get<T>()));
 }
 
 // Method to be called when a PhotonEvent is received
 public static void OnPhotonEventReceived(EventData data)
 {
 // Cast the data code to a NetEvent
 var evnt = (NetEvent) data.Code;
 // Execute the ReactiveCommand with a new NetEventParam containing the event and custom data
 _netEventParam.Execute(new NetEventParam<object>(evnt, data.CustomData));
 }
} The method should be called in your class implementing the . We can now work with network events, just like we did before, with UI events: OnPhotonEventReceived Photon interface IOnEventCallback.OnEvent // Enum for network events
public enum NetEvent
{
 // Event for player state
 PlayerReady,

 // Event for client ping
 ClientPing,

 // Event for battle finish
 BattleFinish,

 // ...
}

// Method to raise the PlayerReady event
public void OnGameLoaded()
{
 // Raise the PlayerReady event with the player's ID
 **NetEvent.PlayerReady.Raise(_playerId);**
}

// Method to subscribe to the PlayerReady event
public void SomeGameManagerOnAnotherDevice()
{
 _disposable = new CompositeDisposable
 {
 // Subscribe to the PlayerReady event
 **NetEvent.PlayerReady.Subscribe<int>(OnPlayerReady)**
 };
} Other types of buses A bus can be characterized not only by the method of delivery, but also by the environment for message propagation. The above examples show buses that deliver events at runtime, but we can also identify a separate bus for editor events (in Edit and Play-mode): [InitializeOnLoad]
public static class EditorBridge
{
 // Static constructor that is called when the class is loaded
 static EditorBridge()
 {
 var disposable = new CompositeDisposable
 {
 // Subscribe to the event and log a message when it is raised
 **EditorEvent.SomeEventName.Subscribe**(() => Debug.Log("Editor event"))
 };

 // Add a handler to the EditorApplication.quitting event
 // that disposes of the CompositeDisposable
 EditorApplication.quitting += () => disposable.Dispose();
 }

 // Create a menu item in the Tools menu
 [MenuItem("Tools/Raise Test Event")]
 public static void RaiseTestEvent()
 {
 **EditorEvent.SomeEventName.Raise();**
 }
} In this case, the implementation of the and methods will not differ from . In Edit-Mode, the event bus can be used to exchange messages between different custom editors, allowing for interface updates and synchronizing data between them. Subscribe Raise UiEventExtensions Another useful type of bus is a . In the previous examples, the sent event is executed synchronously in the same frame. However, there are tasks that require time for processing but do not demand immediate execution. For such events, a separate manager is required which will check whether there is enough time in the current frame to execute the handlers, or whether to wait for the next frame: deferred execution bus public class DelayedEventsProcessor
{
 // This method is called when the game starts
 [RuntimeInitializeOnLoadMethod]
 public static async void Init()
 {
 // Create a cancellation token source
 var source = new CancellationTokenSource();
 // Store the current delta time
 var time = Time.deltaTime;

 // While the cancellation is not requested,
 // the queue is not empty
 // and the execution limit is not exceeded
 while (!source.IsCancellationRequested 
 && !DelayedEventsQueue.IsEmpty()
 && (Time.deltaTime - time) > ExecutionLimit)
 {
 // Process the events in the queue
 DelayedEventsQueue.ProcessEvents();
 // Waiting for next frame
 await Task.Yield();
 // Update the delta time
 time = Time.deltaTime;
 }
 
 // When the application is quitting, cancel the token
 Application.quitting += () => source.Cancel();
 }
} One can separately highlight the bus, and its events will only be handled in development builds and will be turned off in release configurations. DebugEvent Pros and cons of event buses Using the event bus pattern improves Unity game architecture, simplifies development and maintenance, and enhances flexibility and performance. Let’s look in more detail: : The Event Bus pattern allows for the separation of game logic into components, which simplifies its understanding and maintenance. Each component can process only the events it needs, reducing coupling and increasing system flexibility. Separation of logic : Using an event bus makes it easy to add and remove components, simplifying game expansion and functionality changes. Flexibility : Events processed through the bus can be called asynchronously, improving game performance and reducing the likelihood of delays in operation. Asynchronicity : The event bus pattern can be used to create plugins and modules that can be easily integrated into the game. Extensibility However, it should be remembered that the Event Bus can also lead to some negative effects: : events that are processed through the bus can be triggered asynchronously, which makes it difficult to debug the application. Worsening of debugging : if event processing is not organized correctly, unpredictable interaction between components may occur, leading to errors and failures. Loss of flow control : code that uses the event bus may be harder to understand and maintain, as different components may be subscribed to the same event. Increased code complexity : transmitting messages through the bus can increase the delay in application operation, as events must be processed at the other end of the bus. Increased message transmission delay Conclusion We’ve learned how to use enums to mark data buses and message types, and have explored how to wrap event buses transmitted in different ways and in different environments with enums. Putting it all together, we can use this approach to uniformly handle any type of event, thereby improving code readability and comprehension. public void Initialize()
{
 _disposable = new CompositeDisposable
 {
 // Uniform subscription to events 
 // incoming from different buses

 **UiEvent.ExitBattleClick**.Subscribe(OnExitBattleClick), 

 **BackendEvent.BattleReset**.Subscribe(OnBattleReset),

 **DelayedEvent.ChangeWindDirection**.Subscribe<Direction>(OnChangeWindDirection),

 **NetEvent.PlayerReady**.Subscribe<PlayerReadyData>(OnPlayerReady),

 **DebugEvent.KillOpponentUnits**.Subscribe(OnKillOpponentUnits),

 **EditorEvent.SelectScene**.Subscribe<string>(OnEditorSelectScene),
 };
} To recap once more: the event bus pattern has several advantages, such as reducing the coupling between components, more flexible and extensible code, and the ability to handle messages asynchronously. However, its use can lead to code complexity and increase the difficulty of debugging the application. Therefore, before using the pattern, it is necessary to carefully evaluate its necessity and advantages in a specific project. . Source code is available on GitHub

Using an Enum-Based Event Bus Pattern In Unity

How Do You Deploy a Payment Gateway? - Practical Uses for Payment APIs

Hi! In this blog, we will see how to integrate paytm payment gateway in React-Native. Mobile wallets have become immensely popular in recent years, and paytm is highly trusted among online customers. Many people use it every day for doing online recharges, DTH & other bill payments. It reduces the risk of exposing customer’s banking credentials and credit card details to hackers. Therefore, Paytm is a good solution for online payments on your Website and Mobile Apps. Before we begin integrating paytm gateway into our React-Native app, create an account on paytm as a merchant. Step 1: Installing Required Libraries Install the following libraries in your React-Native app npm install paytm_allinone_react-native — save
npx react-native link Step 2: Including the Necessary Maven Repository In the project level, build.gradle file add the following line in the repositories section allprojects {
  repositories {
      ...      maven {
          url "https://artifactory.paytm.in/libs-release-local"                   }   
}
 } Step 3: Including Necessary Libraries to Make HTTP Requests Next in the app level build.gradle file add the following dependencies implementation "com.squareup.okhttp3:okhttp:4.2.1"
implementation "com.squareup.okhttp3:logging-interceptor:4.2.1" 
implementation "com.squareup.okhttp3:okhttp-urlconnection:4.2.1" Step 4: Installing Core Node-js Module Crypto After all of this is done, some other things need to be done, which are not mentioned in the official documentation of PayTm. First of all, install core node-js module crypto as mentioned in this article in your react native app. React-Native**-Randombytes** Step 5: Installing Once the crypto module is installed and React-Native-Randombytes is installed, go to the paytmchecksum folder located inside the node_modules folder. Make the following changes to paytmchecksum.js file. //import crypto module from root directory
const crypto = require('./../../crypto')
//Import randombytes dependency 
import { randomBytes } from 'react-native-randombytes' Make sure your generateRandomString function located in paytmchecksum.js looks like this: static generateRandomString(length) {
   return new Promise(function (resolve, reject) {
      randomBytes((length * 3.0) / 4.0, function (err, buf){                       if (!err) {
             var salt = buf.toString("base64");
             resolve(salt);
       }
          else {
            console.log("error occurred in generateRandomString: " + err);
        reject(err);   }
    });
  });
 } Step 6: Writing a Method to Initiate the Transaction and Generate Transaction Token Once all these things are done, we can actually start writing code for making payments. We will use the fetch module instead of the HTTPS module to make requests. To make any transaction, we first need to generate a transaction token. //method to get txn token 
import PaytmChecksum from 'paytmchecksum'
const merchantId ="Your merchant Id"
const data = {orderId:"01",txnAmount:"1",customerId:"001"}
export function getTxnToken(data){
   
           var paytmParams = {};
           paytmParams.body = {
             "requestType"   : "Payment",
             "mid"           : merchantId,
             "websiteName"   : "WEBSTAGING",
             "orderId"       : data.orderId+"",
             "callbackUrl"   : "https://merchant.com/callback",
             "txnAmount"     : {
                 "value"     : data.txnAmount,
                 "currency"  : "INR",
              },
             "userInfo"      : {
                 "custId"    : data.customerId,
             },
  //You can enable any other modes if you want 
   "enablePaymentMode":[
            {"mode" : "UPI",channel:     ["UPI","UPIPUSH"]}, {"mode":"DEBIT_CARD",channel:["RUPAY"]}
            ]
          };
PaytmChecksum.generateSignature(JSON.stringify(paytmParams.body), "L&qCdepjSHKzEX0l").then(function(checksum){
    paytmParams.head = {
       "signature"    : checksum
    };
     var post_data = JSON.stringify(paytmParams);
     var options = {
         /* for Staging */
         hostname: 'securegw-stage.paytm.in',
         /* for Production */
         // hostname: 'securegw.paytm.in',
          port: 443,
          path: '/theia/api/v1/initiateTransaction?'+    'mid='+merchantId+'&orderId='+data.orderId+'',
          method: 'POST',
         headers: {
           'Content-Type': 'application/json',
           'Content-Length': post_data.length
         },
         body:post_data
};
fetch('https://securegw-stage.paytm.in/theia/api/v1/initiateTransaction?mid='+merchantId+'='+data.orderId+'',options)
.then((response)=>{
    response.json()
    .then((txnToken)=>{
//here call the method to start transaction.
     startTransaction({orderId:"01",txnToken:txnToken,amount:"1"});   
     })
   .catch((error)=>{
      //Handle the error
      console.log(error);
      })
    })
  })
 
} Step 7: Writing a Method to Start a Transaction Once we have the method to generate a transaction token, we can write a method to start a transaction. import AllInOneSDKManager from 'paytm_allinone_react-native';
const data = {orderId:'01',txnToken:"",amount:"01"}
export function startTransaction(data){
   
       
       AllInOneSDKManager.startTransaction(      data.orderId,merchantId,data.txnToken,data.amount,"https://merchant.com/callback",true,false)
.then((txnDetails)=>{
   //txn is successful
   //Verify the txnDetails call fetchTxnStatus method
   fetchTxnStatus({orderId:"01"})
  }).catch((error)=>{
      //handle the error
      console.log(error);
   })
 
} Step 8: Writing a Method to Fetch Transaction Status Once the transaction is successful, we have to fetch transaction status from paytm servers and then show the payment confirmation message to the user. Here’s how to fetch transaction status. //function to fetch transaction status of a transaction
export function fetchTxnStatus(data){
   
      
      var paytmParams = {};
      paytmParams.body = {
      "mid" : "your merchant Id",
      "orderId" : data.orderId+'',
    };
   PaytmChecksum.generateSignature(JSON.stringify(paytmParams.body),     "your_merchant_key").then(function(checksum){
   paytmParams.head = {
     "signature" : checksum
   };
  var post_data = JSON.stringify(paytmParams);
  var options = {
     hostname: 'securegw-stage.paytm.in',
     /* for Production */
    // hostname: 'securegw.paytm.in',
    port: 443,
    path: '/v3/order/status',
    method: 'POST',
    headers: {
       'Content-Type': 'application/json',
       'Content-Length': post_data.length
     },
    body:post_data
};
fetch("https://securegw-stage.paytm.in/v3/order/status",options)
.then((response)=>{
    response.json().then((txnStatus)=>{
    
    if(txnStatus.body.resultInfo.resultCode=="01"){
       //show that the transaction was successful
       //You can call a function to confirm the payment
       console.log("Transaction Successful");
}else{
       //show that there was some problem with transaction
       //txnStatus.body.resultInfo.resultCode=="400" means pending
       //complete list of responses and their meanings
}
  })
 .catch((error)=>{
     //handle error
     console.log(error);
    })
   })
 });
 
} That’s all, folks! Now you can start receiving payments. References https://developer.paytm.com/docs/all-in-one-sdk/hybrid-apps/react-native/ https://developer.paytm.com/docs/api/initiate-transaction-api/?ref=payments https://javascript.plainenglish.io/using-core-node-js-modules-in-react-native-apps-e6002a33b6ff https://developer.paytm.com/docs/api/v3/transaction-status-api/?ref=payments

How to Integrate the Paytm Payment Gateway in Your React Native Apps

Huge cranes are lifting heaps of dirt in a remote mine in a desert of Australia. There are excavators, scrapers, drills, loaders, lifts and earthmovers working in unison to dig iron, lithium, gold and diamonds. Each machine with thousands of moving parts working 24×7 in a harsh environment requires close monitoring and maintenance to keep it running. This requires dedicated maintenance personnel and a stock of spare parts in all locations. Any breakdown that results in significant downtime means a huge loss. An indoor organic hydroponic farm is humming with lights, fans, nutrient mixers and water pumps in a five-star hotel in the city of Orlando, FL. Strict climate control with optimal conditions is required to keep plants growing well. Any failure of components, even for a short duration of time can affect the quality of the green produce. An electric car is self-driving on the roads of California. The IoT sensors in the engine are continuously feeding data to a central server which is monitoring the engine performance, optimizing the run and predicting any potential failures. The advent of for fast connections, IoT sensors to monitor and fast analytics infrastructure to churn data has enabled the upcoming area of decision science. The heart of decision science is predictive analytics. 5G connectivity What is Predictive analytics? Predictive analytics uses many techniques from data mining, statistics, modeling, machine learning, and artificial intelligence to analyze real-time data to make predictions about the future. Advance Analytics allows organizations to become proactive, forward-looking, and help in making future decisions based upon the data instead of a hunch. In this blog, we talk about our implementation of predicting failures of components in an engine based on the continuous collection of sensor data. Predictive Analytics Process Training Data We used data from system/device logs collected from the automobile engine. The sensors built into the engine send various parameter values like device temperature, pressure, strength. Each one of these parameters has multiple states with their threshold values. When the engine runs, the parameter values may cross these threshold limits raising alerts. Approach The way to predict these alerts is to first predict the future values of these parameters based on the values already received. We broke down our approach into two steps- Predict parameter values and generate an alert, if the predicted values go beyond the pre-defined limit. Build a model to predict error events with error messages using predicted values from step 1, so that the user can know beforehand that an error message will come at a certain time with certain probability. Data Preprocessing Since the data generated from device logs was unstructured and untidy, various pre-processing techniques were used to add  structure and meaning: data type conversion removing outliers identifying patterns to examine errors at runtime finding specific commands which yield information about the state and parameter values.missing value treatment Model Building & Prediction We predict the values of parameters for the next one hour and their states based on the already collected data and use of LSTM (Long-short term memory) model. For example, if a parameter has two states, we built models for both the states and continuously predicted the values for the next hour. With the help of predicted parameter values and mapping predicted values with device manuals, we had the information about when a value may go beyond its threshold. Using this information we designed the system to send alerts 5 minutes before the expected alert time. We built a classification model for events as based on the predicted parameter values obtained from step one. To build the classification model we split the data into training and test sets in the ratio of 70:30. To overcome the class imbalance problem we applied an upsampling method on training data and again split that 70% data into training and test sets. The purpose of this splitting is to validate our model on both balanced and imbalanced data. Error or No Error We tested different machine learning algorithms on both balanced and imbalanced data. Classification models used were . Among all these algorithms performance of the Random forest model on both balanced and imbalanced test data was much better than the other two as shown below. Logistic Regression, Gradient Boosting and Random forest As we can see from above that the class error percentage given by the Random forest model is minimum as compared to other algorithms. Model Deployment and Serving We developed a test dashboard called Predictive Maintenance Tool with the following functionality: The user can upload the device logs manually or trigger the tool to know about when an error is going to happen based on the runtime events. Display the graph of predicted values for different parameter values. Place to manually enter the error which happened unexpectedly and not in the device manual but resolved by service/maintenance engineer, so that they can add it for future reference. Challenges Data imbalance caused the problem of less information to classify events as Error and No Error. Untidy data.Multiple errors occurring at the same time.Mapping of predicted parameter values with manuals. Due to fluctuation in devices at run time there is a gap in the generated value of logs. Conclusion The predictive analytics machine learning model worked well to provide alerts before the engine values went beyond thresholds avoiding expensive repair costs to the automobile owners. As machine learning models get embedded into edge devices, a combination of such locally generated predictive alerts with server-side machine learning to provide feedback loop will provide efficiency and disaster recovery in all verticals like automobiles, manufacturing, agriculture, and healthcare. Also published on: https://47billion.com/blog/predictive-analytics-maintenance-of-events-using-machine-learning/

Predictive Analytics for Maintenance Events 

Introduction has become a prominent technology in implementing data APIs. It provides a convenient and intuitive approach for querying data. Let’s look at a sample use case using the programming language and see how GraphQL compares to other traditional approaches such as implementing REST-style HTTP APIs. GraphQL Ballerina Use Case: E-commerce Data Query Let’s take a typical e-commerce scenario of processing orders in an online store. The entity-relationship diagram below shows a typical representation that can be used in a relational database. This is of course a simplified representation of a real-life implementation. One approach for exposing such a data set would be to create a service with operations for each database table. This would be similar to the following. getOrder(id): OrderInfo getCustomer(id): CustomerInfo getShipper(id): ShipperInfo In this manner, we do get rather granular access to the data where we can query each table’s records as we need. However, we have to read the full table record at a time. If we have a large number of fields in a table, this may result in a larger message transported to the user, even if most of the fields may not be used by the application. This is an over-fetching scenario, but generally, it’s not a big problem in this type of situation. Now, let’s say the application needs to look up order details as well as the information about the customer. Then it needs to do two separate service operations “getOrder” and “getCustomer”. The following sequence diagram shows this interaction. Note that the service operations are done sequentially since we need the “OrderInfo” to look up the “customerId” to do the “getCustomer” operation. So for the application, this means two network round trips to look up both order and customer information. This becomes worse as we need more information, such as looking up “shipper” information also at once. For applications such as mobile apps where this communication is happening through a high-latency network, such as the Internet, it would hamper the user-experience. So ideally, we need to cut back on the number of service calls we do when a user interacts with an application. In order to reduce the number of service calls, we can have an operation such as “getFullOrderInfo” which will load all the data in connection with an order from the service and send them at once. This would definitely solve our multiple request problem. But, if we just have this single operation, even when we want to look up something like the order date, we will receive lots of unwanted data. This is a potentially problematic over-fetching scenario. If we want to properly fix this situation, we need separate individual operations for all the combinations that are possible, such as “getOrderAndCustomer”, “getOrderAndShipper”, etc. This is obviously not a practical solution for a service developer. If only there is an approach, where the application can dynamically query the service on which parts of the data set is required. This is exactly what GraphQL does. Solution: GraphQL In GraphQL, we can define an object graph in our service, where a client can query the specific fields of an object. These fields can be queried at any nested level. Optionally, we can pass in parameters for these fields as well. A definition of these objects for our use-case can be shown below. type Query {
   order(id: Int): Order
} Order {
   id: Int
   notes: String
   customer: shipper: Shipper
} {
   name: String
   address: } Shipper {
   name: String
   phone: String
} type Customer type Customer Address type The above is actually written in the GraphQL schema format used to define object types. GraphQL “Query” is a special object type, which must exist for the schema. This is basically the root level object that a user will query. So in GraphQL queries, we provide the fields inside the “Query” object to look up the required data. Provided that we have a GraphQL service with the schema above, we would send the following query to get a similar effect to our earlier “getOrder” operation. {
   order( ) {
       notes,
       date
   }
} id: 1 Here, we instruct our service to lookup the “order” field from the root query object and pass in ‘1’ as the value for parameter “id”. This field returns an object type, so we need to list all the fields we require from the object, where we provide “notes” and “date” above. If we need to only look up the date field, our GraphQL query would be the following. {
   order( ) {
       date
   }
} id: 1 We can drill into more fields and get their values as well. The following query, looks up full order information, including the customer and shipper information. {
   orders(id: 2) {
       notes,
       date, {
           name, },
       shipper {
           name,
           phone
       }
   }
} customer address Now that we understand the basics of how GraphQL works, let’s take a look at how to do the actual implementation using some code. We will use for this task. It is a programming language that has GraphQL as part of its built-in language-level services support. Ballerina Implementation: Ballerina GraphQL Services In Ballerina, the GraphQL object structure is modeled using services. A Ballerina GraphQL service contains resource methods that map to the fields of the GraphQL objects and work as resolver functions to provide its data. The GraphQL schema is automatically derived from this service structure and its resources. : GraphQL support is available from Ballerina Swan Lake release and onwards. NOTE The following code shows a simple GraphQL service we can write in Ballerina. import ballerina/graphql; graphql:Service /query on new graphql:Listener(8080) { function name() returns string {
       return ;
   }

} service resource get "Jack" The code above exposes a GraphQL service at the endpoint. Its GraphQL schema is similar to the following. { : String
} type Query name We can send the following GraphQL query to lookup the exposed “name” field in the root query object. { } name Let’s run the Ballerina code above for a sample test run. $ bal run demo.bal
Compiling demo.bal
Running executable
[ballerina/http] started HTTP/WS listener 0.0.0.0:8080 source A GraphQL request can be executed by sending an HTTP request similar to the following. $ curl -X POST -H -d http://localhost:8080/query
{ :{ : }} "Content-type: application/json" '{"query":"{name}"}' "data" "name" "Jack" The resource functions here can be provided with parameters to correlate with the GraphQL field parameters as well. Also, in the case of returning objects in fields, the resource method can return a service object to represent this. Let’s see how we implement our order information query scenario using a Ballerina service. We start with the Ballerina GraphQL service implementation, which represents the GraphQL root “Query” object fields. import ballerina/graphql;

service graphql:Service /query on graphql: {

   resource get 'order( id) 
                          returns Order load ;

} new Listener(8080) function int |error => Order( ) id Here, we have a single resource function “order”, which takes in the “id” parameter and returns an instance of the “Order” service class. The “loadOrder” function and the “Order” service class is implemented in the following way. function loadOrder(int id) returns Order| {
   stream<record{}, error> rs = dbClient->query(`SELECT id, customerId,
                                                 shipperId, date, notes ORDERS WHERE id = `, OrderData);
   var rec = check rs.next();
   check rs.close(); !(rec is ()) {
       return new Order(<OrderData> rec[ ]);
   } {
       return (string `Invalid order: `);
   }
} class Order {

   private OrderData data;

   function init(OrderData data) {
       self.data = data;
   } function notes() returns string {
       return self.data.notes;
   } function date() returns string {
       return self.data.date;
   } function customer() returns Customer| {
       return check loadCustomer(self.data.customerId);
   } function shipper() returns Shipper| {
       return check loadShipper(self.data.shipperId);
   }

} error FROM ${id} if "value" else error ${id} service resource get resource get resource get error resource get error Here, we execute the required SQL query to load the “Order” table data and populate the “Order” object. Note that, we do not also load “customer” and “shipper” information right away, but rather, these are loaded lazily if and when it is required as expressed through the incoming GraphQL query. The “loadCustomer” function shown below is used in the “customer” resource function to load the customer information from the database and populate a “Customer” object. function loadCustomer(int id) returns Customer| {
   stream<record{}, error> rs = dbClient->query(`SELECT id, name, WHERE id = `, CustomerData);
   var rec = check rs.next();
   check rs.close(); !(rec is ()) {
       return new Customer(<CustomerData> rec[ ]);
   } {
       return (string `Invalid customer: `);
   }
} class {

   private CustomerData data;

   function init(CustomerData data) {
       self.data = data;
   } function name() returns string {
       return self.data.name;
   } function address() returns string {
       return self.data.address;
   }

} error address FROM CUSTOMER ${id} if "value" else error ${id} service Customer resource get resource get Similarly, the “shipper” resource function is implemented to query the corresponding GraphQL object field. The full source code for the scenario above can be found . here Let’s do a test run using our full Ballerina service implementation. We are using a MySQL database to provide the data. Let’s create and populate the database first. Navigate to the “ordersvc” directory which contains the Ballerina package and the database script. $ mysql -u root -p < db.sql Let’s execute the default module of our Ballerina package in the following manner. $ bal run .
Compiling laf/ordersvc:0.1.0
Creating balo
        target/balo/laf-ordersvc-any-0.1.0.balo
Running executable
[ballerina/http] started HTTP/WS listener 0.0.0.0:8080 source Let’s send some GraphQL requests to the service. $ curl -X POST -H -d { : { : { : , : , : { : , : }, : { : , : }
       }
    }
}
$ curl -X POST -H -d { : { : { : , : { : , : }
       }
    }
} "Content-type: application/json" '{ "query": "{ order(id: 2) { notes, date, customer { name, address }, shipper { name, phone } } }" }' 'http://localhost:8080/query' "data" "order" "notes" "Street pickup" "date" "2021/01/25" "customer" "name" "Nimal Perera" "address" "No 22, Galle Road, Colombo 02" "shipper" "name" "UPS" "phone" "(408)275-4415" "Content-type: application/json" '{ "query": "{ order(id: 1) { notes, customer { name, address } } }" }' 'http://localhost:8080/query' "data" "order" "notes" "Doorstep delivery" "customer" "name" "Jack Smith" "address" "No 10, N 1st St, San Jose" Ballerina GraphQL services also support GraphQL introspection. For example, the following query can be executed to lookup the types available in the service. $ curl -X POST -H -d { : { : { : [{ : }, { : }, { : }, { : }, { : }, { : }, { : }, { : }, { : }, { : }, { : }]
       }
    }
} "Content-type: application/json" '{ "query": "{ __schema { types { name } } }" }' 'http://localhost:8080/query' "data" "__schema" "types" "name" "Order" "name" "__TypeKind" "name" "__Field" "name" "Query" "name" "__Type" "name" "Customer" "name" "Shipper" "name" "__InputValue" "name" "String" "name" "Int" "name" "__Schema" Summary GraphQL is a technology that makes data querying tasks much more efficient and intuitive for the users. Here, we have looked at how it solves potential problems such as data over-fetching and solves network latency problems that can arise in a services-based solution. Ballerina provides built-in support for implementing GraphQL services in a quick and easy manner, where the user can just concentrate on the business logic. For more information on Ballerina and its GraphQL support, check out the following resources: Ballerina by Example Ballerina API Documentation GraphQL Sample Also published at https://medium.com/ballerina-techblog/graphql-made-easy-with-ballerina-5ca04d9536d0

Querying Data With GraphQL & Ballerina

With all the assumptions we make about the advancements in enterprise data and cloud technologies, there’s a plain fact that often gets overlooked: The majority of the most important enterprise data remains in the corporate data center. There are plenty of reasons for this — some reasonable, some not so much. In some cases, it’s because of the highly sensitive nature of data, whether it’s HIPAA compliance, sensitive banking data or other privacy concerns. In other cases, the data resides in systems (think legacy enterprise resource planning data or petabyte-scale scientific research data) that are difficult to move to the cloud. And sometimes, it’s just inertia. It’s not a great excuse, but it happens all the time. Whatever the reason, housing data on racks of corporate servers has proved to be a real hindrance to many enterprises’ ability to take advantage of AI to transform their business, because it’s been all but impossible to provide the significant compute power necessary to drive AI on the infrastructure underpinning most data centers. But there’s a movement under way, via a small constellation of startups and big device makers, to optimize machine learning models and make AI available to companies whose data isn’t in the cloud. It’s going to be a game changer. The processing power problem The graphical processing unit, or GPU, was developed to handle high-intensity video-processing applications like those required by modern video games and high-resolution movies. But the ability of these processors to break down complex tasks into smaller tasks and execute them in parallel also makes these high-powered application-specific integrated circuits (ASICs) very useful for artificial intelligence. AI, after all, requires massive streams of data to refine and train machine learning models. CPUs, on the other hand, are the flexible brains of servers, and, as such, they are built to handle a wide variety of operations, like accessing hard drive data, or moving data from cache to storage, but they lack the ability to do these tasks in parallel (multicore processors can handle parallel tasks, but not to at the level of GPUs).They simply aren’t built to handle the kind of high-throughput workloads that AI demands. High-performance GPUs are very expensive and until recently, they’ve been scarce, thanks to the reliance of crypto miners on these high-performance chips. For the most part, they’re the realm of the cloud providers. Indeed, high-performance computing services are a big reason companies move their data to the cloud. Google’s , or TPU, is a custom ASIC developed solely to accelerate machine learning workloads. Amazon also has its own chips for powering AI/ML workloads. Tensor Processing Unit Optimizing for AI GPUs have been the foundation of the rush of AI innovation that has recently taken over the headlines. Much of these high-profile developments have been driven by companies pushing the envelope on what’s possible without thinking too much about efficiency or optimization. Consequently, the workloads produced by new AI tools have been massive, and so, by necessity, managed in the cloud. But in the past six months or so, that’s been changing. For one thing, the sprawling ML models that drive all of these cutting-edge AI tools are getting condensed significantly, but still generating the same powerful results. I installed the app on my mobile phone, for example. It’s a 13 billion-parameter model that does ChatGPT-like execution and runs in real time, right on my phone. It’s not in the cloud at all – it’s an app that resides on a device. Vicuna The Vicuna project emerged from the , a collaboration between UC Berkeley, UC Davis and Carnegie Mellon University with the mission to “make large models accessible to everyone by co-development of open datasets, models, systems, and evaluation tools.” Large Model Systems Organization It’s a mission that big tech isn’t ignoring. Apple’s latest desktops and iPhones have specialized processing capabilities that accelerate ML processes. Google and Apple are doing a lot of work to optimize their software for ML too. There’s also a ton of talented engineers at startups that are working to make hardware more performant in a way that makes AI/ML more accessible. is a great example. The company offers a software-based engine that can train large deep-learning models by using CPUs. DataStax has been experimenting with the ThirdAI team for months and has been impressed with what they have developed — so much so that last week we announced a partnership with the company to make sophisticated large language models (LLMs) and other AI technologies accessible to any organization, regardless of where their data resides. (Read more about the partnership news ). ThirdAI here Bring AI to the data Because of all this hard work and innovation, AI will no longer exclusively be available to organizations with data in the cloud. This is extremely important to privacy, which is a big reason many organizations keep their data on their own servers in the first place. With the AI transformation wave that has washed over everything in the past 18 months or so, it’s all about data. Indeed, there is no AI without data, wherever it might reside. Efforts by teams like ThirdAI also enable all organizations to “bring AI to the data.” For a long time, companies have been forced to do the opposite: bring their data to AI. They had  to dedicate massive resources, time and budget to migrate data from data warehouses and data lakes to dedicated machine learning platforms before analyzing for key insights. This results in significant data transfer costs, and the required time to migrate, analyze, and migrate affects how quickly organizations can learn new patterns and take action with customers in the moment. Bringing AI to the data is something we have focused on a lot at DataStax with our , because it’s the fastest way to take actions based on ML/AI, delight customers and drive revenue. Bringing AI to the data center, and not just the cloud, is another very important step to making the transformational AI technology wave something all companies can be a part of. real-time AI efforts *Learn about the new which connects enterprises with groundbreaking AI startups to accelerate the development and deployment of AI applications for customers.* DataStax AI Partner Program , By Ed Anuff, DataStax Also published . here

Bringing AI to the Datacenter

Llevando la IA al centro de datos

Apporter l'IA au Datacenter

डाटासेंटर में एआई लाना

AIをデータセンターに導入

Trazendo IA para o Datacenter

Đưa AI vào Datacenter

将 AI 引入数据中心

Did you know that you can push your laptop from being an ordinary computer to a Micro-Datacenter powering a cluster and then back to an ordinary computer in only 15 minutes? Kubernetes Yes, you read right. 15 minutes to get your own private Kubernetes cluster up and running on your laptop. Microservices and Kubernetes are the hype. But how do you get started with more about these two exciting topics? learning I will show you every step of the way and get you up to speed with a learning environment on your laptop. By the end of this post you will be all set to experiment and explore Kubernetes on your laptop. The diagram below gives you an overview of what your Micro-Datacenter will look like when we are done setting it up. We will leverage a virtualisation layer (consisting of containers and virtual machines) running on your laptop hardware. Docker On this virtualisation layer we will run which will help us with setting up and managing our Micro-Datacenter as well as the Kubernetes cluster. Rancher Here are the 5 short steps to build your Micro-Datacenter Install the dependencies ( & ) Docker Virtualbox Install Rancher Server Create a environment in Rancher Kubernetes Add two nodes (virtual machines) to the Kubernetes cluster Run a ‘Hello World’ service in Kubernetes nginx First things first. 1. Install the Dependencies There are only two dependencies to get us on our way: We need Docker installed on your laptop ( and follow the instructions to install Docker) click here We need Virtualbox installed on your laptop ( and follow the instructions to install Virtualbox) click here Take a minute and install them both if you have not done so already. When you are done with installing go ahead and start Docker. Docker is running The screen shots and terminal commands in this post are taken from a Mac. However, with very few exceptions (which I will point out) you should be fine following along on either Linux or Windows. Let’s get started (check your watch :) 2. Install Rancher Server will manage our Micro-Datacenter and our Kubernetes cluster. Let’s fire up Rancher in a Docker container. Rancher Server Open a terminal on your laptop and copy-paste the following command (one line): > docker run -d --restart=unless-stopped -p 8080:8080 rancher/server:stable ### The Rancher Server will take some time to get up and running.### You can tail the logs to check Rancher's progress> docker psCONTAINER ID IMAGE rancher/server:stable 4a3dcbaaa4ba > docker logs -f 4a3dcbaaa4ba Once Rancher is up and running you can point your browser to and access the Rancher Server’s web interface. localhost port 8080 Later on we want our two Kubernetes nodes (virtual machines) to connect to the Rancher Server. The two nodes will not be able to use the localhost address to connect. Therefore we need to add an alias to the localhost interface on our laptop. Let’s assign a as an alias. private IP address I have chosen as a random private IP address. Note it does not matter what private IP address you choose. You will be fine as long as you stay clear of the more common ones (like 192.168…. or 10.0….). Staying clear of these ranges of private IPs will help avoiding networking conflicts. 10.145.10.1 Note for Windows users: Assigning the alias might be somewhat different on Windows. Please use caution and read up on the details for your OS. For Linux users the below commands should look very similar. ### Add the alias > sudo ifconfig lo0 alias /24 10.145.10.1 ### Check with to see whether the alias has been added ifconfig > ifconfig ** **_nd6 options=201<PERFORMNUD,DAD>_ lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> mtu 16384options=1203<RXCSUM,TXCSUM,TXSTATUS,SW_TIMESTAMP>inet 127.0.0.1 netmask 0xff000000inet6 ::1 prefixlen 128inet6 fe80::1%lo0 prefixlen 64 scopeid 0x1 inet 10.145.10.1 netmask 0xffffff00 Verify that you can reach the Rancher Server web interface by pointing your browser to the alias on 10.145.10.1 port 8080 3. Create the Kubernetes environment in Rancher At the top left corner on the Rancher web interface click on then select Environment Manage Environments > Add Environment Give the new environment a name (ie ‘Kubernetes Demo’). Choose the Environment Template, then scroll down and click ‘Create’. Kubernetes Create a Kubernetes Environment You will now see new environment in the drop down in the top left corner. Click on it. ‘Kubernetes Demo’ Environment At this stage Rancher is waiting for us to add infrastructure nodes to the newly created Kubernetes environment. Rancher waits for infrastructure nodes to be added 4. Add two nodes (virtual machines) to the Kubernetes cluster We create the two virtual machines using the command from Docker (note you could add as many nodes as your hardware can support, but for the demo two are enough). docker-machine For our two Kubernetes nodes we could use any Linux distro machine image that comes with Docker installed. However, Rancher distributes a tiny container optimised image called . We’ll use Rancher OS. It is perfect for our use case. Rancher OS Go back to your terminal and copy-paste the command from the box below (one line). Note: once with and then with to create our two nodes. run the command twice kube-box-1 kube-box-2 ### Create a Rancher OS virtual machine with 3G of RAM (one line) > docker-machine create -d virtualbox --virtualbox-memory "3072" --virtualbox-boot2docker-url **kube-box-1 https://releases.rancher.com/os/latest/rancheros.iso ** ### Run the command again now for the second node > docker-machine create -d virtualbox --virtualbox-memory "3072" --virtualbox-boot2docker-url https://releases.rancher.com/os/latest/rancheros.iso kube-box-2 Rancher OS comes with Docker pre-installed. Unfortunately, the default version of Docker is newer than Kubernetes likes its Docker to be. We have to to a suitable version (1.13.1). switch Docker on the two nodes Login to each of the two nodes and change the Docker version. ### ssh to kube-box-1 > docker-machine ssh kube-box-1 ### and switch the Docker version to 1.13.1 then logout [docker@ ~]$ sudo ros engine switch docker-1.13.1[docker@ ~]$ exit kube-box-1 kube-box-1 ### then for the second node do the same > docker-machine ssh kube-box-2 [docker@ ~]$ sudo ros engine switch docker-1.13.1[docker@ ~]$ exit kube-box-2 kube-box-2 Fantastic. Our two nodes are now ready to join the Kubernetes cluster. In the next step we will run a little script on both of the two nodes to register them with Rancher and join the Kubernetes environment. For the registration script we will need the nodes’ IP addresses (note your nodes’ IP addresses might be different). ### Retrieve the IP address for kube-box-1 > docker-machine ip kube-box-1192.168.99.100 ### and the IP address for kube-box-2 > docker-machine ip kube-box-2 192.168.99.101 We have got all the info we need. It’s time to go back to the Rancher web interface and click on ‘Add a host’ Add a host Keep the default ‘ ’ setting for the new node. Custom Then scroll down to step 4. There specify the IP address for as retrieved above ( or whatever the value is that has allocated in your case). kube-box-1 192.168.99.100 docker-machine Rancher needs the IP address to communicate with its infrastructure nodes. Enter the node’s IP address and copy the registration script Copy the command from step 5. This is the registration script to run the Rancher agent on . kube-box-1 Go back to the terminal on your laptop and login to using the command we already used above. kube-box-1 docker-machine ssh ### ssh to kube-box-1 > docker-machine ssh kube-box-1 ### on run the script from the Rancher web interface kube-box-1 [docker@ ~]$ sudo docker run -e CATTLE_AGENT_IP=" ” -d --privileged -v /var/run/docker.sock:/var/run/docker.sock -v /var/lib/rancher:/var/lib/rancher rancher/agent:v1.2.1 kube-box-1 192.168.99.100 http://10.145.10.1:8080/v1/scripts/F6FC06D291DDADE7F0B7:1483142400000:8dr5IQ1NsrNG2pEX2hLh7XPppI ### wait for the command to complete then logout [docker@ ~]$ exit kube-box-1 Do all of the above (starting from ‘Add a host’) again to register kube-box-2. Important! Remember to copy-paste the IP address for (ie ) in step 5. Bad things will happen if you register kube-box-2 with kube-box-1’s IP address. kube-box-2 192.168.99.101 Rancher is now busy provisioning the two nodes with the Kubernetes services. Switch to to watch the Kubernetes services coming up on the two nodes. Infrastructure > Hosts Rancher provisions Kubernetes services on the two nodes It will take some time for Rancher to download and install the images for the Kubernetes services on the two nodes. Be patient. Depending on your internet connection this might take quite some time. There are several ways to tell when your Kubernetes cluster is configured and up and running. One way is when Rancher will start providing a link to open the Kubernetes dashboard ( ). Kubernetes > Dashboard You have some time while Rancher is hard at work spinning up your Kubernetes cluster. Have a play with Rancher’s web interface to see what else it offers that we did not discuss yet. Kubernetes is ready. You might want to checkout the Kubernetes dashboard. 5. Run a ‘Hello World’ nginx service in Kubernetes Now, to the exiting part! We have Kubernetes running in our Micro-Datacenter. In good old fashioned tradition let’s run the ‘Hello World’ of Microservices: A simple web server (serving a default web page). nginx Kubernetes provides the command line tool to configure its resources. kubectl With Rancher Server we can either choose to run from the console in the web interface or kubectl if you have installed on your laptop then Rancher gives us the configuration file to copy over to the laptop. kubectl kubectl Both options are available from the menu in the Rancher web interface. Kubernetes > CLI For simplicity we will use Rancher’s web console for running kubectl. Of course you are free to on your laptop and configure it with the config provided by Rancher (click on the button as shown on the screen shot below). Having installed on your laptop will come in handy when you start doing more interesting stuff with your Kubernetes cluster later. install kubectl ‘Generate Config’ kubectl kubectl shell in the Rancher web interface (or check out the config file if you run kubectl on your laptop) For your convenience I created a with the Kubernets configuration files ( ) to run the nginx ‘Hello World’ example. github repo *.yaml All you need to run the nginx example (a Kubernetes deployment and Kubernetes service) is executing the two ‘ commands in Rancher’s web console. kubectl create -f …’ Clone the if you either intend to run from your laptop or you want to study the content of the two files. github repo kubectl yaml ### Copy-paste the commands and enter them on Rancher's web console ### Create a deployment (spinning up two nginx pods) > kubectl create -f https://raw.githubusercontent.com/danaschwanden/micro-datacenter/master/HelloWorld/nginx-deployment.yaml deployment “dep-nginx” created ### Check to see the deployment we just created > kubectl get deployments _NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGEdep-nginx 2 _ 2 2 2 6s ### Check to see the two pods the deployment created > kubectl get pods NAME READY STATUS RESTARTS AGEdep-nginx-3655994670–2gks0 1/1 Running 0 10sdep-nginx-3655994670–53dfd 1/1 Running 0 10s ### Create a service to expose the nginx services on the two nodes > kubectl create -f https://raw.githubusercontent.com/danaschwanden/micro-datacenter/master/HelloWorld/nginx-service.yaml service “svc-nginx” created ### The service is configured to use “NodePort”### Kubernetes master will allocate a random port from a### flag-configured range (default: 30000–32767)### Let's check on what port the service exposes nginx > kubectl get services NAME CLUSTER-IP EXTERNAL-IP PORT(S) AGEsvc-nginx 10.43.164.192 <nodes> 8080: 32767 /TCP 12s Note the output of the command above. It tells us two things: ‘kubectl get services’ The nginx service ( ) is exposed on the external IP svc-nginx <nodes> on port (might be different in your case). 32767 This means nginx is now available on both our on port . nodes 32767 Let’s verify that we can reach nginx by pointing the browser to either of the nodes’ IP addresses at the port the Kubernetes service has assigned. For example to access nginx via . Note that your IP address and port might be different. Change them accordingly. http://192.168.99.100:32767 kube-box-1 Et voila . Your laptop is running a Micro-Datacenter with Kubernetes and nginx as a simple show case service. Congratulations Over to you now to play with the setup at your heart’s content. We barely touched the surface of what can be done. Go wild. I hope you will enjoy your new datacenter powers. Once you are done you probably want to clean up and free up the resources. Cleaning up is just as easy as it was to set up the environment. Simply follow the 5 steps below. Cleaning up As promised we want to leave your laptop as pristine as we found it at the beginning of this post. Let’s get the broom out. a) Stop the Kubernetes service and deployment. ### In the Rancher web interface console run > kubectl delete service svc-nginx service “svc-nginx” deleted > kubectl delete deployment dep-nginx deployment “dep-nginx” deleted b) Stop the two nodes and remove them ### In the terminal on your laptop run > docker-machine stop kube-box-1 > docker-machine stop kube-box-2 > docker-machine rm kube-box-1 > docker-machine rm kube-box-2 c) Remove the alias on your laptop’s localhost interface. If you are on Windows or Linux this step might be slightly different. Please use caution and read up on it for your OS. ### In the terminal on your laptop run > sudo ifconfig lo0 10.145.10.1 -alias d) Stop the Rancher Server container and remove it ### In the terminal on your laptop run > docker psCONTAINER ID IMAGE rancher/server:v1.6.3 4a3dcbaaa4ba > docker stop **4a3dcbaaa4ba**> docker rm 4a3dcbaaa4ba > docker imagesREPOSITORY TAG IMAGE ID rancher/server v1.6.3 b4c15b304585 > docker rmi b4c15b304585 Done. I hope you enjoyed the journey (have you checked the time?) PS: As always: . “The opinions stated here are my own, not those of my company” Useful Links The that inspired this one Rancher post The Rancher documentation The Rancher OS documentation The Kubernetes documentation The nginx documentation

DATACULT

datacult.co.in

-- employees

Since n.d.

COMPANY RANKING

DATACULT

EVERGREEN INDEX #2660

Representing this company? Click here to claim and customize this page!

DataCult WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

DATACULT

datacult.co.in

-- employees

Since n.d.

COMPANY RANKING

DATACULT

EVERGREEN INDEX #2660

RELATED COMPANIESRANK

STORIES ABOUT DATACULT

Representing this company? Click here to claim and customize this page!

DataCult WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!