fabiochiu/medium-articles huggingface dataset:
Pivoting
Tags: Exchange, Defi, Binance Smart Chain, Yield Farming, Dex

“The only constant - change”

Autofarm was incepted to be a user-first automated DeFi platform. Since the launch, many users have been concerned about the 3 main issues below. We have injected an immense amount of thought into all concerns, and have come up with the following changes to promote the sustained growth of Autofarm.

We’d like to thank the relentless support from the community thus far.

https://autofarm.network

Front-running

There have been arguments for and against by the community. Although not yet an issue, we do hear your concerns. The most common solution to this would be a small withdrawal fee to prevent trading around the time earn() is called.

Solution

An entrance fee. 100% of this fee will go to funds already in the pool. :)

This method is not considered common practice and might deter deposits in the first place. However, savvy investors might and should be encouraged to be early liquidity providers, to be entitled to a share of all entrance fees of users depositing after him/her.

To pilot this, we will be introducing an entrance fee of 0.3% to new vaults (many will be coming soon).

Should this fee become a deterrence to late-comers when the platform has blossomed, it will and should be voted upon by the community governance.

Value of the AUTO token

The AUTO token provides an incentive to use the Autofarm platform and to allow users to own a stake in the future of the platform, which further strengthens the value of Autofarm.

Such network effects should not be overlooked.

Solution

The team will be more transparent about the future of the platform, hence indirectly, the value of the AUTO token.

AUTO-WBNB liquidity pool will be added for users to subscribe and unsubscribe to the future of Autofarm. This is not intended to be a degen pool.

AutoSwap

No, this is not another Uniswap fork.

AutoSwap aims to be the leading DEX aggregator on BSC — think 1inch.exchange. DeFi automation doesn’t come without automatic swaps across multiple DEXes.

Swap fees will benefit AUTO holders.

More details will be released on AutoSwap in the near future.

Sustainability & Fees

A 0.1% controller fee on profits will be activated to cover gas fees on every earn().

At a later date, a percentage of profits from vaults will be used to buyback AUTO to burn.

AutoFi

Automatic yield farming was just the start. We aim to be a one-stop DeFi platform.

AutoFi will be the umbrella platform under which other such DeFi innovations will reside on.
AI changing the future of Banking, Key to Crypto
Tags: Exchange, Investing, Banking

Since we can understand the applications that artificial technologies are bringing to the world. We can start with SIRI all the way to self-driving cars, artificial intelligence (AI) is progressing rapidly. Artificial intelligence can encompass anything from Google’s search algorithms to IBM’s Watson to autonomous weapons.

Meanwhile, a narrow AI may outperform humans at whatever its specific task is, like playing chess or solving equations, AGI would outperform humans at nearly every task. So collective analytic algorithms embedded into the algorithm are bringing rich results, according to statistics.

The implications that K2Crypto using can be described by simple digital banking advantages starting leveraging Fintechs for a better customer experience, through the rise of Neobanking to better regulations and relationships. A good article that summarises is written here in Forbes at the beginning of the following year.

Key to Crypto provides tailored solutions to individuals looking for a friendly ecosystem where finance management is the key. By integrating the most powerful AI algorithms to improve the way they analyze securities and make investment advice, while others use it to improve core operational processes. AI can lead to better predictions, fewer errors, bringing greater efficiency for the investment industry. A growing number of companies, large and small, are finding new ways to incorporate the technology into their own operating models.

Those who embrace the digital revolution and the rise of AI point that some of that technology is already here and it clearly benefitting many people. Including investors in income property, who rely on a multitude of apps and interfaces designed to make handling investment property that much easier.

Open your opportunities by exploring countless open-source platforms or take a peek at rasing technologies of the new world banking management here at K2Crypto.
BTCNEXT 取引所のアップデート#23
Tags: English, Project News, Exchange, Crypto, Btcnext

Learn more. Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Make Medium yours. Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore
BTCNEXT Exchange Update #23
Tags: English, Project News, Exchange, Crypto, Btcnext

The work is on fire here at the BTCNEXT HQ! We want to share some crucial and revolutionary updates but you’ll have to wait a bit more! Instead, we’ll present other updates from the past two weeks. Check them out!

Financial markets

At the beginning of last week, the price of gold rose sharply and we expected a return to the uptrend for the first time since August. But in the end, the quotes returned to the level of the weekly opening, near the support of $1,840 per ounce.

The oil markets have been growing steadily throughout the past week and it wasn’t until Friday that the price correction occurred. As a result, WTI oil reached $46.65 per barrel. Quotes strengthened amid expectations of large aid packages for the economy and the start of mass vaccinations.

There is a sideways movement in the index market. At the time of writing, the S&P 500 was trading at $3,655, The Dow Jones at $29,860.

Crypto market

The crypto market capitalization didn’t change over the last 7 days. Most cryptocurrencies on the BTCNEXT Exchange remain at the same levels. XMR grew the most: +11% per week. XRP dropped more than the others, losing 17% of its value. The NOAHP price hasn’t changed. BNX dipped 45%, QDAO — 17%.

For the past two weeks, Bitcoin remained at the same levels by Monday. $19,000 turned out to be the mark that Bitcoin is tied to. The main cryptocurrency tried to fight for $20,000 but failed. It also dipped a few times but always bounced back to $19,000. Altcoins can afford such uncertainty and a substantial number of them have dropped in value. For the moment Bitcoin reached $22,000.

BTCNEXT Exchange update

Our tireless team is constantly working to bring BTCNEXT users the best conditions and services. This time, we cannot share many updates but we are preparing something big in the coming weeks. Stay tuned… you will be amazed!

We’ve updated the information about the Spark token airdrop. BTCNEXT and QDAO DeFi users with XRP on their balance will get Ripple’s Spark token air-dropped in 2021, after the snapshots taken in December 2020. This is the native token of Flare, the new Turing-complete FBA network by Ripple Labs.

Daily volumes and statistics on the BTCNEXT Exchange:

BTC — $14.5m

ETH — $12.1m

BNX — $135,000

NOAHP — $1,500

QDAO — $69,000

The total average daily volume on the exchange is $66m.

We hope you are just as excited about these updates as we are. Come back in two weeks for a new portion of news!
¿Cómo crear un reenviador de correos sencillo usando AWS SES y Serverless?
By: Andrés Morelos
Tags: Serverless, Aws Simple Email Service, Amazon Web Services, Serverless Architecture

AndresMorelos/aws-simple-email-forwarding

This is a simple implementation zero code needed for an email forwarder using Serverless, AWS SES. Note: create a JSON…
Run NestJS Application in Serverless Framework on AWS
By: Muhd Mohaiminul Islam
Tags: Nestjs, AWS Lambda, AWS, Serverless, Nodejs

In this article, we’re going to learn how we can run a NestJS application as a Lamda function using the Serverless framework on the AWS platform.

NestJS application in Serverless framework on AWS

Hands-on Steps:

Create NestJS application:

First, we need to install Nest CLI globally to create a NestJS application.

npm i -g @nestjs/cli nest new nest-sls && cd nest-sls

Install node dependencies for Serverless:

These are the node packages that we need to install first before we proceed.

npm install aws-lambda aws-serverless-express express --save

Map NestJS with ExpressJS:

Here we map our NestJS application into the ExpressJS application so that we can use this during AWS Lamda function implementation.

// src/app.ts import { NestFactory } from '@nestjs/core';

import { ExpressAdapter } from '@nestjs/platform-express';

import { INestApplication } from '@nestjs/common';

import { AppModule } from './app.module';

import { Express } from 'express'; export async function createApp(

expressApp: Express,

): Promise<INestApplication> {

const app = await NestFactory.create(

AppModule,

new ExpressAdapter(expressApp),

);

return app;

}

Convert ExpressJS to AWS Lamda:

Now we convert our ExpressJS application into AWS Lamda function so that it can use our application as a function.

// src/serverless.ts import { Server } from 'http';

import { Context } from 'aws-lambda';

import { createServer, proxy, Response } from 'aws-serverless-express';

import * as express from 'express';

import { createApp } from './app'; let cachedServer: Server; async function bootstrap(): Promise<Server> {

const expressApp = express();

const app = await createApp(expressApp);

await app.init();

return createServer(expressApp);

} export async function handler(event: any, context: Context): Promise<Response> {

if (!cachedServer) {

const server = await bootstrap();

cachedServer = server;

}

return proxy(cachedServer, event, context, 'PROMISE').promise;

}

Create a configuration file:

Here we mentioned all the configurations for the Serverless application.

// serverless.yml service: serverless-nestjs frameworkVersion: '2' useDotenv: true provider:

name: aws

runtime: nodejs12.x

stage: ${opt:stage, 'dev'}

region: ${opt:region, 'ap-southeast-1'}

apiGateway:

shouldStartNameWithService: true

environment:

NODE_ENV: ${env:NODE_ENV} functions:

app:

handler: dist/serverless.handler

events:

- http:

method: any

path: /{any+}

Build and deploy the Serverless application:

Make sure, we always build our application before deploying to AWS. Because all the changes will reflect after the build process is successful as we upload the files from the dist directory into AWS S3.
Server-less technology reading list
By: David Wu
Tags: Serverless, Taucoin, Dht

I would love to compose an academic reading list for folks want to learn server-less technolog.

DHT, the distributed hash table, sitting at the core of the server-less stack. Here is the must read to understand DHT protocol. Mutable and Immutable data handing: this is how peer to communicate with other peers without servers by using DHT. Here is the protocol. Github resources: here is the libtorrent repo, which implements DHT and data store. Here is the android java wrapper of libtorrent.
Serverless Web Application : 1 — Introduction
By: Recep Ozcelik
Tags: Amazon S3, AWS Lambda, Amazon Cognito, Serverless, Azure Functions

What is Serverless?

Serverless is a development model that allows developers to build and run applications without having to manage servers. There are still servers in serverless, but they are abstracted away from app development. A provider handles tasks related with infrastructure. Developers can simply package their code in containers for deployment.

Don’t think about hardware or infrastructure

Easily scale your application (flexible)

High availability, because they are thinking about everything for you

Pay for use. You pay as requests you get

Serverless web application solution by Amazon

AWS Serverless Web Application Architecture

Amazon S3 => Simple Storage Service(S3) is storage for the Internet (static web hosting)

=> Simple Storage Service(S3) is storage for the Internet (static web hosting) Amazon Cognito => User management and authentication functions to secure the backend API

=> User management and authentication functions to secure the backend API Amazon API Gateway => Creating, publishing, maintaining, monitoring, and securing REST, HTTP, and WebSocket APIs at any scale

=> Creating, publishing, maintaining, monitoring, and securing REST, HTTP, and WebSocket APIs at any scale AWS Lambda => Compute service that lets you run code without provisioning or managing servers

=> Compute service that lets you run code without provisioning or managing servers Amazon DynamoDB => Fully managed NoSQL database service

Serverless web application solution by Azure

Azure Serverless Web Application Architecture

Azure Blob Storage => Object storage solution for the cloud (static web hosting)

=> Object storage solution for the cloud (static web hosting) Azure Active Directory => Cloud-based identity and access management service

=> Cloud-based identity and access management service Azure API Management => Create consistent and modern API gateways for existing back-end services

=> Create consistent and modern API gateways for existing back-end services Azure Functions => Compute service that lets you run code without provisioning or managing servers

=> Compute service that lets you run code without provisioning or managing servers Azure Cosmos DB => Fully managed NoSQL database service

References:
Build An App That Books Vacations To The Moon with GraphQL, Lambda, DynamoDB, Serverless Framework, Vue, React and TailwindCSS 🌝
By: Amo Moloko
Tags: AWS, Vuejs, GraphQL, Serverless, React

When I started my first job I really struggled to setup an app with this stack. I had to piece different tutorials together and it was a nightmare. Eventually I setup a boilerplate project to scaffold a Serverless GraphQL API in JavaScript and TypeScript. While there are lots of examples of how to use GraphQL on the frontend there were few resources on how to develop and deploy a fullstack project. So I also needed a bleeding edge app on hand for me to refer to from time. So this guide is meant to be your resource to achieve it. It is quite opinionated , so if it does not fit in with your stack you can look at different parts of the project and take what you need.

The beauty of this course is that you can choose your own adventure on the frontend between Vue and React. On the Vue side we explore how to scaffold a project using Vue CLI and manage state in a parent component across its children. While if you choose to do the frontend part of the course in React, you will learn how to use Apollo’s Local Cache as a replacement for Redux.

Tailwind CSS is creeping into everyone’s workflow to manage their CSS, while I believe you can use it in conjunction with Styled Components in your React app, it introduces different benefits for styling your app. These benefits are:

Giving you complete ability to build custom styles without overriding existing styles.

Easier to build responsive UI.

Easier to adopt and implement your design system into code.

This project was hugely inspired by the folks over at Anomaly Innovations who created the Serverless Stack which is a course that teaches you to ship Serverless APIs with REST.

The wait to get your hands on how to build a fullstack serverless GraphQL app is over! Get it for Free!
Optimizing Serverless in AWS
By: Chameera Dulanga
Tags: Serverless, Performance, Web App Development, Best Practices

1. Avoid Lambda Cold Starts with Provision Concurrency

When developing APIs using Serverless services in AWS, we use API Gateway and Lambda to run our backend code. And these functions start upon receiving events from API Gateway.

Lambda has become very cost-effective due to this on-demand invoking mechanism. On the other hand, the time taken to start the function directly impacts application performance.

AWS provides two methods to overcome this problem, and you can choose one based on your requirements and cost.

Using Lambda Ping

The first solution is to use a CloudWatch event rule and scheduled event to ping the Lambda function regularly (every 5 min or 10 min).

CloudWatch Event Rule

Usually, the Lambda execution environment has about 10 to 15 minutes of idle time, and if there were no Lambdas invoked during that time, the execution environment is removed. So, with this approach, we can keep the execution environment up and running continuously.

It’s essential to keep an exit path in your code to handle the scheduled event and execute it faster, reducing the execution cost.

Using Lambda Provision Concurrency

The second solution is to use a Lambda provision concurrency to create pre-warmed execution environments. You have the freedom to decide the number of pre-warmed environments you need.

Once you define the number of pre-warmed environments, the environment downloads the Lambda code with dependencies and initialize it. So, whenever we get a request from the API gateway, the Lambda service avoids provisioning execution environments repeatedly and uses one of the pre-warmed environments.
Day #12 with Cloud Workflows: loops and iterations
By: Guillaume Laforge
Tags: Serverless, Workflow, Google Cloud Platform, Google Cloud

In previous episodes of this Cloud Workflows series, we’ve learned about variable assignment , data structures like , and switch conditions to move between steps, and expressions to do some computations, including potentially some built-in functions.

With all these previous learnings, we are now equipped with all the tools to let us create loops and iterations, like for example, iterating over the element of an array, perhaps to call an API several times but with different arguments. So let’s see how to create such an iteration!

First of all, let’s prepare some variable assignments:

- define:

assign:

- array: ['Google', 'Cloud', 'Workflows']

- result: ""

- i: 0

The array variable will hold the values we’ll be iterating over.

The result variable contains a string to which we’ll append each values from the array.

And the i variable is an index, to know our position in the array.

Next, like in a for loop of programming languages, we need to prepare a condition for the loop to finish. We’ll do that in a dedicated step:

- checkCondition:

switch:

- condition: ${i < len(array)}

next: iterate

next: returnResult

We define a switch, with a condition expression that compares the current index position with the length of the array, using the built-in len() function. If the condition is true, we’ll go to an iterate step. If it’s false, we’ll go to the ending step (called returnResult here).

Let’s tackle the iteration body itself. Here, it’s quite simple, as we’re just assigning new values to the variables: we append the i-th element of the array into the result variable, and we increment the index by one. Then we go back to the checkCondition step.

- iterate:

assign:

- result: ${result + array[i] + " "}

- i: ${i+1}

next: checkCondition

Note that if we were doing something more convoluted, for example calling an HTTP endpoint with the element of the array as argument, we would need two steps: one for the actual HTTP endpoint call, and one for incrementing the index value. However in the example above, we’re only assigning variables, so we did the whole body of the iteration in this simple assignment step.

When going through the checkCondition step, if the condition is not met (ie. we’ve reached the end of the array), then we’re redirected to the returnResult step:

- returnResult:

return: ${result}

This final step simply returns the value of the result variable.
Days #11 with Cloud Workflows: sleeping in a workflow
By: Guillaume Laforge
Tags: Serverless, Workflow, Google Cloud Platform, Google Cloud

Workflows are not necessarily instantaneous, and executions can span over a long period of time. Some steps may potentially launch asynchronous operations, which might take seconds or minutes to finish, but you are not notified when the process is over. So when you want for something to finish, for example before polling again to check the status of the async operation, you can introduce a sleep operation in your workflows.

To introduce a sleep operation , add a step in the workflow with a call to the built-in sleep operation:

- someSleep:

call: sys.sleep

args:

seconds: 10

- returnOutput:

return: We waited for 10 seconds!

A sleep operation takes a seconds argument, where you can specify the number of seconds to wait.

By combining conditional jumps and sleep operations, you can easily implement polling some resource or API at a regular interval, to double check that it completed.
Architect 8.4: say hello to Lambda treeshaking
By: Ryan Block
Tags: Serverless, JavaScript, AWS, Software Development, Nodejs

One of the thing that sets OpenJS Architect apart from other serverless tools is its opinion that serverless apps work best when composed of many small, discrete Lambda cloud functions.

This approach offers the greatest coldstart performance, security isolation, deployment speed, and mean time to bug resolution. However, this approach also comes with a minor drawback: the need to manage many Lambdas’ dependencies.

Or at least it used to! Architect 8.4 introduces a new concept we call Lambda Node.js modules treeshaking.

How Lambda treeshaking works

If you’d like to take advantage of the nearly 1.5 million publicly published Node.js modules, your Architect app may have numerous individual package.json files spread across its various Lambdae. Here’s an example file tree of how such a project might look:

/

├─ src/

│ └─ http

│ ├─ get-index

│ │ ├─ index.js

│ │ └─ package.json

│ ├─ post-api

│ │ ├─ index.js

│ │ └─ package.json

│ └─ put-api

│ ├─ index.js

│ └─ package.json

├─ app.arc

└─ package.json

Architect 8.4’s Lambda Node.js modules treeshaking now automatically statically analyzes all of your Lambdas’ business logic and manages each of their dependencies from the root. This means:

You only ever have to install dependencies one time in one place: your root package.json

Similarly, upgrading, removing, or otherwise maintaining dependencies happens in your root as well

Perhaps our favorite: no more having to keep dozens (or hundreds) of individual package[-lock].json files in your repo

Now the project above looks like this:

/

├─ src/

│ └─ http

│ ├─ get-index

│ │ └─ index.js

│ ├─ post-api

│ │ └─ index.js

│ └─ put-api

│ └─ index.js

├─ app.arc

└─ package.json

Get started with Lambda treeshaking

For starters, make sure you’re running Architect 8.4 ( npm i @architect/architect@latest )!

For new projects, taking advantage of Lambda treeshaking is as simple as adding dependencies to your project’s root package.json file (and require() ing¹ them in your business logic).

For existing projects, any Lambdas that already have their own package.json will continue to have their dependencies wholly managed by you, meaning you can choose to mix and match dependency management on a per-Lambda basis.

We think this is a massive step forward in the ergonomics of building cloud function-native applications — we’d love to hear what you think in Architect’s Slack!

¹ Architect will ship ESM support when Lambda ships Node.js 14 support; dynamic requires are not supported
Serverless mit AWS Lambda — Hands-On
By: Datev Eg
Tags: AWS Lambda, AWS, Tech Blog, Serverless, It

Learn more. Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Make Medium yours. Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore
Azure Service Bus nedir? Queue ve Topic kullanımı.
By: Ufuk Aytaş
Tags: Azure Service Bus, Messaging, Serverless, Cloud Computing, Azure

By signing up, you will create a Medium account if you don’t already have one. Review our Privacy Policy for more information about our privacy practices.
How to Use Cloud Functions on Huawei AGC?
By: Hakan Erbaş
Tags: Huawei, Cloud Functions, Hms, Faas, Serverless

What is Cloud Functions? How can we use Huawei cloud functions in recipe finder application?

Photo of Kara Eads on Unsplash

Hello everyone,

Nowadays, definition of serverless architecture entered into our lives for some reasons. By this way, developer does not have to think about location, bills, maintenance of server because there is no server which should be configured. Term of FaaS (Function as a Service) occured by serverless architecture. It is a type of Cloud Computing System and functions are triggered by events. FaaS model can be implemented by 3rd party applications.

Huawei introduced the FaaS model; Cloud Functions. To use and have experience on it, It needs application by email.

Huawei Cloud Functions provide us a serverless environment which work together with other services in AppGallery Connect which are event sources for cloud functions. Listening to the event sources to trigger the function. You can see the price information in the guide of Cloud Function on Huawei Developer.
Lessons learned: AWS AppSync Subscriptions
By: Filip Pýrek
Tags: Lessons Learned, AWS, Serverless, Aws Appsync, Serverless Framework

This article of mine is on Purple Technology Blog:

https://blog.purple-technology.com/lessons-learned-aws-appsync-subscriptions/
Build your Microservices the Easy Way with OperatorHub
Tags: Red Hat Openshift, Kubernetes, Openshift, Operators, Serverless

On the 19th of December, Lungelo Sikobi and I delivered a workshop on OperatorHub on Red Hat OpenShift as part of the IBM Developer Series.

In the workshop, we gave an overview of Operators and OperatorHub then we moved on to the code lab where we demonstrated the OpenShift Serverless Operator.

In this blog, I’m sharing an overview of the workshop which you can also watch the replay of here.

What are Operators and what is OperatorHub?

A Kubernetes operator is a method of packaging, deploying, and managing a Kubernetes application. This application is both deployed on Kubernetes and managed using the Kubernetes API and kubectl tooling.[1]

Red Hat OpenShift uses Kubernetes operators to run the entire platform autonomously and as part of OpenShift, you can use these operators through OperatorHub where you can install a library of operators that have been packaged for easy lifecycle management and you can use them in your cluster.

What is OpenShift Serverless Operator?

Serverless is a deployment model where you can scale up and down your applications on-demand based on event triggers, this way the developers can focus more on their code without worrying much about the underlying infrastructure.

OpenShift Serverless is based on the Knative project which allows the deployment of its serverless components on top of Kubernetes, which means that your code only runs when it needs to with Knative starting and stopping automatically.

What did we build in the code lab?

The goal of the lab was to demonstrate the Serverless Operator in action. We built a sample application using a CouchDB database to demonstrate the scaling up and down of applications when we make changes or deletions to the database.

In the code lab, we used Knative Serving (to run stateless serverless service) and Knative Eventing (to subscribe to event sources).

You can watch the replay of the workshop and follow along here on IBM Developer Crowdcast and view the resources in this GitHub repo.

More resources on Serverless and Operators on Red Hat OpenShift
CloudWatch Metrics Explorer
By: Matiss Janis Aboltins
Tags: Lambda, AWS, Cloudwatch, Serverless, Amazon

Using the metrics explorer to have a birds-eye view of how my system functioned over the last 13 months.

December 2020 — AWS released a new way to explore metrics across various dimensions. This is the Metrics Explorer.

I'm not one to blow my own horn (since I worked on this product), but as a customer of AWS — I love the product.

A bit of background: my side project uses a lot of Lambda functions to crawl the Latvian real estate market. Up till now, it was quite difficult to see any issues in my platform. CloudWatch alarms weren't quite useful as (1) using them adds cost to the project (which I'm trying to keep as frugal as it's possible) and (2) there's only a handful of crawlers which would make me worried if they went down. All the rest can go down for a week or even a month and I wouldn't be losing any data.

So my usual approach was to just take a peek at the CloudWatch metrics page once a month to see if there have been any recurring issues with the not-so-important Lambdas. This is all fine-and-dandy, but it's labor-intensive — to select each and every Lambda (there are hundreds).

But then the Metrics Explorer came along. With it — it's super easy to select a metric I'm interested in (e.g. errors), select a specific Lambda tag, and then split by another tag. This immediately gives a birds-eye view of all the crawlers (grouped by the site they are crawling) and the errors in each of the groups.

Not only that — it makes discovering other metrics super easy too. For example, one of my crawlers was using running a total of ~10m milliseconds per month. But this was not an important crawler, so I could immediately make the judgment call to change the Lambda to run less frequently. This in turn means I would spend less money on it. Just fantastic!

If you're also an AWS customer — I highly recommend checking out the new Metrics Explorer. See for yourself, how using it could help reduce costs, find issues, or just have a birds-eye view of the system you're running.

—

Disclaimer: I am an AWS employee and I worked on the Metrics Explorer product. This article contains only my personal opinion. In no way does it reflect the views of Amazon.
⚡️ Cloud Functions for Machine Learning become true. Part 1 ☁️
Tags: Machine Learning, DevOps, Serverless, Cloud Computing, Data Science

DeepMux recently announced GPU-powered serverless functions to make your MLOps (DevOps for ML) easier. Let’s talk about Cloud Functions and their use in Machine Learning!

Created with imgflip

Motivation

Modern applications face higher workloads and stricter SLA. It means that more and more effort is needed to be made to meet the production requirements. Serverless approach and Cloud Functions in particular allow you to abstract low-level design and focus on business logic.

What is Cloud Function?

Literally Cloud Function is a piece of code or, should I say a piece of logic, that is placed to serve at the specific endpoint or triggered by changes in data. Cloud Functions are a part of serverless approach.

They are executed and fully managed by a cloud provider on its own infrastructure. In other words, it is an instrument that allows you to avoid tons of routine work and resources keeping your code operational: maintaining, scaling and provisioning it.

Cloud Functions have “pay-per-use” payment model that may lead to reduction in costs by raising billing granularity comparing to instance groups.

Cloud Functions for Machine Learning

Cloud Functions are clearly popular and frequently used in production. Data processing, microservices, IoT and small applications and existing SaaS integrations.

But despite their well-known benefits, its usage in Machine Learning is not so widespread. Well, they may be used for pre-processing or post-processing data used by ML models but not so often for running them.

Common Cloud Function vendors such as AWS, Google Cloud, MS Azure provide only a CPU for their execution. When it comes to running heavy models e.g. computer vision or deep learning GPU is slightly faster and way more cost-effective.

Meet DeepMux Cloud Functions for ML 🎉

DeepMux launched GPU-powered Cloud Functions specially to run ML including heavy deep learning and especially computer vision models.

In the second part of this article, I am going to create web application using deepfake and deploy it within minutes and no worries about Kubeflow or Flask, using only DeepMux Cloud Functions. Stay tuned and subscribe! :) Feedback and comments are strongly appreciated!

In case if you want to start learning DeepMux with yourself, here is a quick start tutorial. Enjoy! :)
Releasing @clarityhub/serverless-simple-router
By: Ivan Montiel
Tags: Serverless, Lambda, Open Source, Nodejs

As part of my on-going efforts to continue to contribute to the open source community, I have released @clarityhub/serverless-simple-router as part of the Clarity Hub, Inc open source ecosystem.

What’s It For?

At Clarity Hub, we use serverless to quickly build new features and deploy without the overhead of configuring servers using kubernetes or docker. This package lets us quickly route incoming requests to controllers so that our code can stay organized within a serverless lambda.

Usage

All of the documentation on how to use the serverless-simple-router can be found in the README of the Github repo, but to give a quick overview: if you map a set of http paths from your serverless.yml file to a single handler, the serverless-simple-router can be used to parse the incoming request to the right controller method.

Example serverless.yml configuration:

service: example

provider:

name: aws

runtime: nodejs12.x

functions:

root:

handler: src/router.default

events:

- http:

path: /

method: any

cors: true

- http:

path: /{proxy+}

method: any

cors: true

Once the http paths are configured to route to the router.js file, you can use the serverless-simple-router:

import { Router, RouteBuilder } from '@clarityhub/serverless-simple-router';

import TaskController from './controllers/TaskController';



const middyMiddleware = [httpHeaderNormalizer(), cors(), bodyParser()]; routes.resource('/tasks', RouteBuilder.crud(TaskController, middyMiddleware));



export default routes.exec();

The above example will automatically map the following routes to Controller method names, while also auto-creating an instance of TaskController:

GET /tasks routes to TaskController.getAll

routes to GET /tasks/:id routes to TaskController.get

routes to POST /tasks routes to TaskController.create

routes to PUT /tasks routes to TaskController.update

routes to DELETE /tasks routes to TaskController.delete

Going Further

The package also supports Inversion of Control by injecting an IoC container into your Controllers automatically. Using a RouteBuilder will also add helpers for RBAC for you to write your own middleware to check the user’s RBAC permissions.

Check It Out

If you would like to check it out, use it in a project, or contribute to the open source community, you can check out our Github repo:
Serverless is about Accountability — Video
Tags: AWS Lambda, AWS, Serverless, Cloud Computing, Google Cloud Platform

Archis Gore, CTO, Polyverse, talks about how Serverless ensures accountability. He also suggests patterns for scaling with Serverless.
How To Solve The “DNS Server Not Responding” Issue?
Tags: Serverless, Internet Protocol, DNS, Troubleshooting

DNS is a server that translates the website into a language that is understandable for computers. But sometimes when you connect a device to your home network and a wifi hotspot with internet access, internet access may fail to work for a lot of many reasons. When the DNS server not responding then it’s connected to the server troubleshooting problem and it is found on the screen.

“DNS Server Not Responding”

The message will appear server DNS address could not found the website name. This one is a common issue found in Windows computers. At the time of browsing, if you get this message on your PC, it shows that your device will not be able to the internet.

A DNS error occurs when one part of your network is not connecting to another portion of the network. DNS server error is one of the common issues found over the internet. The error can occur due to many reasons. Here in this article, we will tackle DNS server error.

How to fix the DNS server not responding error in Windows 10/8/7?

Here you will get the solution to fix the DNS server not responding issue in Windows 10/8/7. Easily follow the guidance and fix your DNS server.

First, open start and type Control Panel & open control panel.

The next step opens the network & internet> Open Network & Sharing Center.

On the net window Open Change Adapter Setting.

Right-click on your network adapter & Select Properties.

Next Select the internet Protocol 4 [TCP/IPV4] Then click on the properties

First Open Start & Type CMD

Right-click Command Prompt and select run as administrator

A Pop-up message appears Press Yes

Then a page appear named “administrator Command Prompt. On the page type netsh int IP reset c:\txt and press enter .

. Then type netsh Winsock reset and then press enter> now type ipconfig/flushdns and then press enter> type exit and press Enter

By using these two different methods anyone can fix the DNS error issue in windows. The steps are easy to follow so if you are facing the DNS error problem the fix the problem now.

How to fix DNS Server in Mac?

Any Mac user can fix a DNS server error in Macbook with just a few clicks. You only have to follow the steps and you can easily fix the DNS server problem.

Click on the left side brand icon of Apple and select System Preferences.

Then find the network icons and click on them.
PAY per USE can derail your Serverless (dream) Budget
By: Dhaval Nagar
Tags: Serverless Architecture, AWS Lambda, AWS, Amazon Web Services, Serverless

This is the 2nd post in the Serverless communications series.

re:Invent 2020 UPDATE: AWS Lambda has changed the billing duration from 100ms to 1ms 🙌 . Check the full update here: https://aws.amazon.com/about-aws/whats-new/2020/12/aws-lambda-changes-duration-billing-granularity-from-100ms-to-1ms/

[POST #1] Select the right Event-Routing service from Amazon EventBridge, Amazon SNS, and Amazon SQS

[POST #2 ] PAY per USE can derail your Serverless (dream) budget

Monitoring tells you whether the system works. Observability lets you ask why it’s not working. https://dashbird.io/blog/observablity-serverless

Serverless and Event-Driven Services

Serverless applications are all about EVENTS. Events drive the whole system. One of the best advantages of using serverless architecture is that we can extend the whole system with the introduction of new subsystems (microservices) that are connected via communication services.

Queue, Pub/Sub, and Streaming Data services can help extend the system easily with patterns like Fan-Out and Service Chaining.

For example, we can add new subscribers to SNS or new targets to EventBridge rules without any modifications to the existing pipeline.

Pay for what you (actually) CONSUME

Pay for CONSUME is the fundamental billing model on which the whole Serverless ecosystem works.

One bad (or overlooked) design decision can derail the whole consumption cycle that might have been working just fine.

For example, let’s take this use case.

Note: This flow example is used to highlight some design problems.

The pipeline interacts with SQS, SNS, and EventBridge to fan-out the event and further writes the data into the DynamoDB table.
Powering WordPress with Auto-Scaling AWS Aurora RDS
By: Rahul Biswas
Tags: AWS, Rds, WordPress, Serverless, Database

I recently inherited a pretty massive site. With over 100,000 posts, 200,000 attachments, and site loads reaching 4000+ visitors and anywhere from 5–9 logged-in authors at any one time, it’s been one of the largest projects I’ve tackled.

While a proper reverse-proxy solution can mitigate the majority of the front-end load on a project like this, handling even just a few logged-in users becomes a bit of a process. You can’t cache those sessions and requests, and some of the uglier and slower queries baked into WordPress core and plugins like Yoast start to rear their ugly heads.

Until the proper query optimizations can be made, I needed to configure the site’s database solution to roll out replicas in response to increasing load. AWS’s auto-scaling Aurora RDS turned out to be a great solution for this. Here’s how it works…

READ THE FULL STORY BY CLICKING HERE
Serverless Slack Chatbot
By: Nadtakan Jones
Tags: Serverless, Lambda, Slackbot, Nodejs

I’ve been the the mode of exploring bot framework and found that slack has a cool node module that support a lot of native main features.

Let’s get our hands dirty!!

Creating an app on slack

Go to the slack app https://api.slack.com/apps Create a slack app and chose where you want to keep your app in the workspace then click Create App

3. Copy App Credentials to use on the backend

Creating a backend slack app using Serverless framework

Install Serverless framework on your local machine

npm install serverless -g

2. Create a new project called serverless-slack-chatbot then you will get a message on your terminal that your project is created.

serverless create --template aws-nodejs --path serverless-slack-chatbot

serverless framework project created

3. run command below to init the project

npm init

4. Install slack module as command below

npm i @slack/bolt @slack/web-api @slack/webhook serverless-http

5. Clone a project to your local computer

6. Replacing Slack app crediential on the environment section

environment: SLACK_APP_CLIENT_ID: Copy this from slack SLACK_APP_CLIENT_SECRET: Copy this from slack SLACK_SIGNING_SECRET: Copy this from slack

7. let’s deploy our backend

sls deploy -v

8. After deployed your backend then you will get an enpoint as image below. We will use this to config our slack app.

Config the slack app

Go to Event Subscriptions and turn it on then pass endpoint on Request URL. In this case, we are using an endpoint that end with slack/events. if everything is right, you should get a green text verified.

2. Adding message.channels & message.im on the subscribe to bot events section and then click save button.

3. Go to OAuth & Permissions page and add chat:write to Bot Token Scopes. After that slack will notify you to reinstall app again.

4. Install our app by go to Basic Information page then click Install your app to workspace.

5. Update our OAuth Access Token & Bot User OAuth Access Token on serverless.yml file then redeploy backend again.

6. Our bot is live!!

Slash commands

Go to slash commands and click create a new command add command that you’d like to use, request url is the same as event subscritpions and short description. hit save button and reinstall your app

slack slash commands

4. Let’s try our slash command by type /echo how are you?

slack slash commands

Check out code here and give me a clap if you’d like this article.
Build a Headless Architecture with AWS Lambda and WordPress
By: Rahul Biswas
Tags: Lambda, AWS, Hosting, WordPress, Serverless

WordPress is the leading choice for websites. It’s an excellent way to manage dynamic content. It’s open-source, so you can add third-party code or write your own to enhance it.

It has some issues, though. You have to keep up with updates to maintain security. It’s all written in interpreted PHP, so it requires enough processing power to keep responses from lagging. A page with a complex theme and many plugins is especially likely to be slow.

An alternative is to use WordPress in “headless” mode as a back end for content, combining it with a different service to create the presentation. AWS Lambda can provide the front-end service, offering scalability and security. The architecture isn’t for everyone, but it’s an excellent choice for some websites.

Web services on AWS Lambda

Amazon’s AWS Lambda is a “serverless” computing platform. Running a Web server on a serverless platform sounds like a contradiction in terms. The explanation is that “serverless,” surprisingly, doesn’t mean “without a server.” It means that server management is transparent to the customer using Lambda.

Serverless computing goes by the more accurate name of “functions as a service.” You create the functions; the service handles the HTTP wrapper. It treats HTTP requests as events. An event triggers a function…

READ THE FULL STORY BY CLICKING HERE
Day #9 with Cloud Workflows: deploying and executing workflows from the command-line
By: Guillaume Laforge
Tags: Serverless, Workflow, Google Cloud Platform, Google Cloud

So far, in this series on Cloud Workflows , we’ve only used the Google Cloud Console UI to manage our workflow definitions, and their executions. But it’s also possible to deploy new definitions and update existing ones from the command-line, using the . Let’s see how to do that!

If you don’t already have an existing service account, you should create one following these instructions . I’m going to use the workflow-sa service account I created for the purpose of this demonstration.

Our workflow definition is a simple “hello world” like the one we created for of our exploration of Google Cloud Workflows:

- hello:

return: Hello from gcloud!

To deploy this workflow definition, we’ll launch the following gcloud command, specifying the name of our workflow, passing the local source definition, and the service account:

$ gcloud beta workflows deploy w09-new-workflow-from-cli \

--source=w09-hello-from-gcloud.yaml \

--service-account=workflow-sa@workflows-days.iam.gserviceaccount.com

You can also add labels with the labels flag, and a description with the description flag, just like in the Google Cloud Console UI.

If you want to update the workflow definition, this is also the same command to invoke, passing the new version of your definition file.

Time to create an execution of our workflow!

$ gcloud beta workflows run w09-new-workflow-from-cli

You will see an output similar to this:

Waiting for execution [d4a3f4d4-db45-48dc-9c02-d25a05b0e0ed] to complete...done.

argument: 'null'

endTime: '2020-12-16T11:32:25.663937037Z'

name: projects/783331365595/locations/us-central1/workflows/w09-new-workflow-from-cli/executions/d4a3f4d4-db45-48dc-9c02-d25a05b0e0ed

result: '"Hello from gcloud!"'

startTime: '2020-12-16T11:32:25.526194298Z'

state: SUCCEEDED

workflowRevisionId: 000001-47f

Our workflow being very simple, it executed and completed right away, hence why you see the result string (our Hello from gcloud! message), as well as the state as SUCCEEDED . However, workflows often take longer to execute, consisting of many steps. If the workflow hasn’t yet completed, you’ll see its status as ACTIVE instead, or potentially FAILED if something went wrong.

When the workflow takes a long time to complete, you can check the status of the last execution from your shell session with:

$ gcloud beta workflows executions describe-last

If you want to know about the ongoing workflow executions:

$ gcloud beta workflows executions list your-workflow-name

It’ll give you a list of operation IDs for those ongoing executions. You can then inspect a particular one with:

$ gcloud beta workflows executions describe the-operation-id

There are other operations on executions, to wait for an execution to finish, or even cancel an ongoing, unfinished execution.

You can learn more about workflow execution in the documentation . And in some upcoming episodes, we’ll also have a look at how to create workflow executions from client libraries, and from the Cloud Workflows REST API.
Cloud Run と Buildpacks で簡単にコンテナ使えるよ！
By: Kazuu Shinohara
Tags: Cloud Native Buildpacks, Google Cloud Run, Containers, Serverless, Google Cloud Platform

Learn more. Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Make Medium yours. Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore
Prendre en main DynamoDB — Fondamentaux
By: Thibault Ruby
Tags: AWS, Dynamodb, Serverless, NoSQL, Database

Learn more. Medium is an open platform where 170 million readers come to find insightful and dynamic thinking. Here, expert and undiscovered voices alike dive into the heart of any topic and bring new ideas to the surface. Learn more

Make Medium yours. Follow the writers, publications, and topics that matter to you, and you’ll see them on your homepage and in your inbox. Explore