Developers can use the Redis-like interface with the Macrometa platform

Redis is one of the most popular open-source in-memory data stores today, named the “Most Loved” database by Stack Overflow for five consecutive years. This year it lost that position to PostgreSQL.

Because of its fast performance, Redis is a popular choice for:

Developers can use the Redis commands with Macrometa and still automatically synchronize data between various locations worldwide in milliseconds.

It can interact with the Macrometa platform in various ways, using a console, an API call, or an SDK. Redis supports both JavaScript and Python SDK.

In the example below, we are using Python SDK to SET string key-value pairs:

In our application we need to retrieve data, we can do that with GET Redis command as shown below:

In this case data is stored on the platform collection in this format:

Keep in mind that expireDate is an optional parameter.

The Redis collection that we created is automatically synchronized across various locations around the world, up to over 175 locations. This leads to low latency times. Developers don’t need to worry about infrastructure and they can use well-known Redis commands they are already familiar with so there is no learning curve.

, and documentation to quickly get started with Macrometa. Sign up for a 

Macrometa Tutorial: Redis As An Interface 

Macrometa Query Workers offer a powerful solution for developers aiming to reduce development time, streamline data management, and optimize query processing capabilities. In this blog, we will examine the essential aspects of Query Workers, highlighting their core features and the numerous benefits they bring to developers.

 consist of named, parameterized C8QL or SQL queries stored within the 

. Accessible through a dedicated REST endpoint, they offer a versatile and scalable approach to executing custom data processing tasks and queries at the network edge. Utilizing Query Workers enables developers to construct the back-end of their applications in mere minutes, rather than days.

Designed for easy set-up and configuration - at the edge

 are designed with you, the developer, in mind. They offer a simple and straightforward experience, requiring minimal setup and configuration to get started. To create a new Query Worker, all you need to do is define a query that performs your desired task. From there, you can easily generate an 

One of the key benefits of Query Workers lies in their ability to run directly at the network edge. This feature significantly reduces latency times for your apps, enabling you to deliver near-instantaneous responses to user 

. Unlike traditional cloud-based data processing solutions, which can be slower and less responsive due to latency in data transmission between the edge and the cloud, Macrometa Query Workers ensure a seamless and efficient experience for you and your customers.

Creating and utilizing Macrometa Query Workers

Creating and updating Query Workers is a breeze with the Macrometa GDN web console, CLI, 

, or by directly interacting with the REST API. Each Query Worker consists of specific query text and may include a parameter set (bind variables). You have the option to set default values for query parameters, making them optional during the execution of your Query Worker. Alternatively, you can require mandatory parameters for each run, with failure resulting in an error.

To illustrate, let's create data for an imaginary shop inventory using the Macrometa console. The dataset we intend to save is represented by the JSON below.

You will be adding a single data point to the inventory, as demonstrated in the image below.

The initial step involves logging in to the Macrometa platform. Once logged in, select the Query Worker tab to access the query editor. If utilizing a 

 to insert data, the query should appear exactly like this:

Enhancing the flexibility of queries, the @ symbol indicates that we're using a field as a parameter, which we refer to as a bind variable. To test the query, simply click the "Run Query" button. If the query performs as expected, you can save it and generate an API endpoint for use in your application. Creating an endpoint is as easy as clicking the "API Endpoint" button, and just like that, you've built the Create operation from the CRUD!

To view the newly added data, query the entire inventory using the following:

This represents the Read operation from the CRUD framework. Converting this query into an API endpoint is a straightforward process, as illustrated in the image below.

Each new query worker has its own endpoint on  Macrometa GDN. Query Workers are organized by 

, enabling developers to have different Query Workers for different geo-regions as well as for different fabrics within the same region.

Macrometa’s integration with Akamai EdgeWorkers

Macrometa Query Workers into a native Akamai EdgeWorker

 and automatically deploy it onto Akamai’s edge. Simply supply your Akamai credentials and with the click of a button, the API gets generated as an Akamai EdgeWorker and is automatically deployed to 1000s of Akamai edge PoPs that query and serve data from adjacent Macrometa regions on Linode. Check out the

 (like a Netflix or a Hulu) that runs on the Akamai edge and Linode leveraging Macrometa, Linode and Akamai EdgeWorkers to see it in action!

Macrometa Query Workers offer a versatile and scalable solution for performing custom data processing tasks and real-time queries. With a straightforward setup process that allows you to focus solely on crafting queries, deployment is effortlessly handled by the Macrometa GDN.

By leveraging the flexibility and scalability of Query Workers, developers can optimize their data management and query processing workflows and incorporate them into existing workflows and processes. This can help improve 

 and minimize latency, allowing developers to execute complex 

 and computations on large datasets quickly and efficiently.

Tutorial: Experience The Power Of Macrometa Query Workers

Imagine you're running an online shoe store that caters to a global customer base. Your customers expect a seamless, low-latency experience when browsing your catalog, and your development team needs an efficient way to build and manage the backend. Macrometa, a 

In this blog post, we'll discuss the advantages of using Macrometa over traditional centralized cloud platforms and walk you through the process of building a shoe store catalog API that provides CRUD and search functionalities.

 architecture simplifies the process of building and managing a geo-distributed application. It provides a single API to access key-value, document, and graph data models, along with built-in search, pub-sub, queueing, complex event processing, and general-purpose computing capabilities.

This stands in contrast to traditional centralized cloud platforms, where developers must design, build, and manage applications that are typically using many various tools and single-purpose databases to achieve similar functionality. Macrometa's platform ensures data consistency and synchronization across multiple regions using proprietary CRDT technology, providing significant advantages for developers working on applications with a global audience.

 is an advanced full-text search engine designed to support key values, documents, and graphs as data models. Unlike traditional full-text indexes, Macrometa Search offers a highly configurable and customizable experience, combining Boolean and generalized ranking retrieval techniques to refine search results. It ranks all Boolean-approved results by relevance using the Vector Space Model in conjunction with BM25 or TF-IDF weighting schemes.

Macrometa Search is equipped with state-of-the-art indexing and search capabilities, enabling sophisticated search operations on 

Search views are virtual collections that enable fast full-text searching across multiple linked collections.

Analyzers parse input values and transform them into sets of sub-values for tokenization, language-specific word stemming, case conversion, and removal of diacritical marks.

Macrometa Search features are integrated into C8QL as a SEARCH operation and a set of C8QL functions. This integration allows for a wide range of use cases, such as performing federated full-text searches over product descriptions in a webshop, retrieving and ranking research database information by relevance, or querying 

 for specific titles and sorting the results by best matching while favoring movies with longer durations.

Key features of Macrometa Search include:

 Perform intricate search operations using Boolean operators to combine multiple conditions and refine results.

 Automatically rank search results based on their relevance to the query.

 or partial matches to enhance the accuracy of results.

 Customize the ranking algorithm and fine-tune the relevance of search results to suit specific use cases.

 Configure analyzers for tokenization, language-specific word stemming, case conversion, and removal of diacritical marks.

Retrieval of both documents and projections of documents:

 Retrieve complete documents or specific projections based on search criteria.

Combinable search queries across multiple data models and access patterns:

 Seamlessly perform search queries across various data models, such as key-value pairs, documents, and graphs.

Geo-replicated search indexes for instant results:

 Benefit from low-latency search results through the geo-replication of search indexes.

 offers a powerful, flexible solution for building advanced search functionality into applications. Its extensive features, configurability, and seamless integration with C8QL make it an invaluable tool for developers looking to create responsive and engaging applications for global audiences.

To demonstrate how easy it is to create a geo-distributed shoe store inventory API with Macrometa, we'll guide you through the following steps:

Create a document collection called inventory:

 In the Macrometa console, create a new document store collection named inventory.

 Import the JSON file containing shoe catalog data into the inventory collection.

 Write your first query to fetch all documents in the inventory collection:

 Name your Query Worker saveProduct and write an INSERT statement to add a new product to the inventory collection. The @ symbol in this query example is a `binding parameter`. They allow you to leave values as wildcards, so you can pass values along when you call the API to dynamically write and read your data.

 Enable high-performance search on the inventory collection by creating a search view named 

 by shoe name. Use the ANALYZER function to perform various search operations and filter results based on size and price range.

 Save the search query as a Query Worker named inventory-search, and now you have a fully functional search API!

By following these steps, you'll have fully functional, geo-distributed shoe store inventory APIs for CRUD and Search that provide a low-latency experience for users around the world.

Macrometa offers a better developer experience and makes building distributed applications easier compared to traditional centralized cloud platforms. Its global data platform, simplified data management, and built-in functionalities such as 

 and Search Views enable developers to easily build applications like a shoe store catalog API, providing a seamless experience for end-users.

 a 30 day trial to get started today, or 

; in my next posts, I’ll be showing you how to use Graphs to create a recommendation engine and 

 (complex event processing) to implement real-time inventory management!


Building a Hyper-Distributed Shoe Store Inventory API with Macrometa

In this blog post, I will outline how Postman helps us build and maintain our tools. We will also discuss how Macrometa uses it to create a better internal and external developer experience. Our platform has various tools like SDKs and CLI that enable developers to utilize the power of a hyper distributed cloud architecture.


Postman is primarily used as an API testing tool, it takes the burden off the developer to create client HTTP requests. That is just one aspect, Postman can also be used for documentation, automated tests, and even aids in the API design phase. We will cover additional options where Postman really shines with its intuitive GUI and sharing capabilities.


Macrometa takes an API-first approach when we roll out new features, so we follow these three steps. The first step is to update our Open API specification, the second step is to update our SDKs, and the third step is to update our documentation. Our goal is to create a seamless and consistent experience for every interaction developers have with the Global Data Network, including related materials.


When we update our Open API specification and deploy a new version of the platform in a test environment the next step would be to support new features in our SDKs. At this point we don’t jump straight to the code, we take a little bit of time to create Postman collections for all new endpoints. After, we do the first initial tests with Postman manually. The goal of that step is to see how the endpoints are designed, what parameters they are using, how the response body works, and how to build a path with parameters. Any response to requests that we get from the API we record in our Postman collection.

Since we have multiple test environments with different features, the first thing that makes our life easier is using environmental variables. Instead of having collections with hard-coded URLs, we can just turn them into variables. Let’s walk through an example.

https://play.macrometa.io/_fabric/_system/_api/function/metadata

Here is an easy way to change test environment:

We only need to create an environment in Postman for this to work.

That leads us to other important environment variables like user access.


Most of the APIs need some kind of authentication, it would be tedious work to add API keys or tokens to each request manually. Postman can save credentials in environments, on the collection level, or a combination of both.

Now that the basics are set up we can start to add requests. Recently we added Edge Functions to our platform, so we updated our collections accordingly.

Let’s take a look at one of the endpoints created. Deploying the Query Worker to the Edge Worker endpoint will deploy the Macrometa Query Worker to Akamai Edge. Endpoint has four query parameters, some of them are mandatory and some of them are set to default. The benefit is that we can turn on and off parameters with one click and see the API response.

How would you go about it in code? We would delete method parameters, add new ones, and run the whole code. It depends on the level of abstraction in the SDK but there is always a doubt if my code is working fine or if the request I am sending is wrong. That can be time-consuming if the structure or code has to be redone. If the Postman collection request is working at least I know the request structure is ok and it is time to check the code. I would argue that it is better to prepare everything before we start to code.


The same idea can be applied to the body. We can change it on the fly and quickly test responses.

In addition to that some endpoints have additional credentials, we can set them up as variables so that we don’t accidentally leak confidential information while sharing collections. You can find more on how to be on the safe side in this article 

Using variables | Postman Learning Center

Now that collections are set up and working for us, we can run them as many times as we want. Postman offers us the option to save every response as an example.

That is beneficial for many reasons. For example, now I can just copy the response and create methods in our tools (SDKs and CLI) that can parse the response object. No need to run a debugger in the IDE and watch the response variable, and no need for 

We know exactly what we need to get. Postman can save multiple examples, a good practice would be to save unsuccessful requests as well. That way, we can show the developers how to handle error requests.

Now it is just a matter of creating an abstraction of endpoints in the SDK. That should be easy work since we know exactly what and how to code.

You can debate after reading this, that this is just a double work, but that is only if you do not consider the added benefit of sharing. It is possible to share collections with your teammates but we went one step further, we are sharing our collections with all the developers using Macrometa.

For developers, it is perhaps easy to read blocks of code used for client requests, but team members are not only developers. Technical writers would benefit directly from Postman collections since they can interact with the platform, check the saved responses, and be confident that they write consistent documentation. The QA team can use Postman collections to build automated tests. When maintained correctly it can be a single source of truth for the whole organization.

We have been using Postman to create the first draft of collections for new features. The GUI that Postman provides helps us to see inconsistencies between various endpoints that support the same feature.

Get started today with Macrometa and Postman

To sum it all up I want to highlight what we are getting with just a little bit of extra effort before we jump into our preferred IDE. Here are five great reasons to implement Postman in your workflow:

While building Postman collections, you can learn how the API works

You can save request and response parameters and be sure of what we need to implement in SDK code

You can share collections with other team members and users of the platform

Your team members that have less technical backgrounds can easily work with the API

Since Macrometa has recorded various responses, it is a good starting point for documentation (ex. document all error requests)

, set up credentials in Postman, and test the platform quickly and easily and check out our 

. Let us know how you are using Postman on our 

Streamline Macrometa API design and testing with Postman 

Macrometa is the hyper distributed cloud platform for enterprises building global applications at the Edge. 

PhotonIQ

Global Data Network

Blog

Learning Hub

Case Studies

Developer Hub

Demos

Support

About

Partners

Press

Careers

Contact Us

Terms of Service

Privacy Policy

Trust Center

Macrometa vs. Edgio

Are you an Edgio customer facing uncertainty? Discover how Macrometa ensures continuity and delivers high-performance solutions for your business.

Macrometa Tutorial: Redis As An Interface

Developers can use the Redis-like interface with the Macrometa platform

What are the benefits?

Get started today!

Macrometa Tutorial: Redis As An Interface

Developers can use the Redis-like interface with the Macrometa platform

What are the benefits?

Get started today!

Related Posts

Tutorial: Experience The Power Of Macrometa Query Workers

Building a Hyper-Distributed Shoe Store Inventory API with Macrometa

Streamline Macrometa API design and testing with Postman