#Lambdafunctions

[govindhtech]

Amazon CloudWatch Application Signals For AWS Lambda

Use CloudWatch Application Signals to monitor serverless application performance created using AWS Lambda.

An AWS built-in application performance monitoring (APM) solution called Amazon CloudWatch Application Signals was introduced in November 2023 to address the challenge of tracking the performance of distributed systems for apps running on Amazon EKS, Amazon ECS, and Amazon EC2. Application Signals expedites troubleshooting and minimizes application downtime by automatically correlating telemetry across metrics, traces, and logs. You may increase your productivity by concentrating on the apps that support your most important business operations using CloudWatch Application Signals‘ integrated experience for performance analysis within your applications.

CloudWatch Application Signals for Lambda

In order to remove the hassles of manual setup and performance concerns associated with evaluating the health of applications for Lambda functions, AWS is announcing today that Application Signals for AWS Lambda is now available. You can now gather application golden metrics (the volume of requests coming in and going out, latency, problems, and errors) with CloudWatch Application Signals for Lambda.

By abstracting away the intricacy of the underlying infrastructure, AWS Lambda frees you from having to worry about server health and lets you concentrate on developing your application. This enables you to concentrate on keeping an eye on the functionality and health of your apps, which is essential to running them at optimal efficiency and accessibility. This necessitates having a thorough understanding of performance insights for your vital business processes and application programming interfaces (APIs), including transaction volume, latency spikes, availability dips, and mistakes.

In the past, determining the underlying cause of anomalies required a significant amount of time spent correlating disparate logs, KPIs, and traces across several tools, which increased mean time to recovery (MTTR) and operational expenses. Moreover, developing your own APM solutions using open source (OSS) libraries or custom code was laborious, complicated, costly to operate, and frequently led to longer cold start times and deployment issues when overseeing sizable fleets of Lambda functions. Without the need for manual instrumentation or code modifications from your application developers, you can now easily monitor and debug serverless application health and performance concerns with CloudWatch Application Signals.

How it works

By delving deeper into performance measurements for crucial business operations and APIs, you may quickly determine the underlying cause of performance abnormalities using CloudWatch Application Signals‘ pre-built, standardized dashboards. This aids in the visualization of the application topology, which displays how the function and its dependencies interact. To keep an eye on particular processes that are most important to you, you may also set Service Level Objectives (SLOs) on your applications. Setting a target that a webpage should render in 2000 ms 99.9 percent of the time over a rolling 28-day period is an example of a SLO.

CloudWatch Application Signals uses improved AWS Distro for OpenTelemetry (ADOT) modules to automatically instrument your Lambda function. You can swiftly monitor your apps with improved performance, including decreased cold start latency, memory usage, and function invocation duration.

Application Signals in the Lambda Console to gather different data on this application using an existing Lambda function called appsignals1.

You can enable the application signals and the Lambda service traces by choosing Monitoring and Operations Tools from the function’s Configuration tab.

This Lambda function is a resource that is attached to myAppSignalsApp, an application. For your application, you have established an SLO to track particular operations that are most important to you. Your objective is for the application to run within 10 ms 99.9 percent of the time within a rolling 1-day period.

After the function is called, it may take five to ten minutes for CloudWatch Application Signals to identify it. You will thus need to reload the Services page in order to view the service.

Now that you are on the Services page, you can see a list of every Lambda function that Application Signals has found for you. This is where any telemetry that is released will be seen.

Then, utilizing the newly gathered metrics of request volume, latency, faults, and failures, you can rapidly identify anomalies across your service’s various processes and dependencies and visualize the entire application topology from the Service Map. You can rapidly determine whether problems affecting end users are specific to a job or deployment by clicking into any point in time for any application metric graph to find connected traces and logs relating to that metric.

Now available

You can begin utilizing Amazon CloudWatch Application Signals for Lambda right now in any AWS Regions where both Lambda and Application Signals are accessible. Lambda functions that use Python and Node.js managed runtimes can now use Application Signals. Support for additional Lambda runtimes will be added soon.

Read more on govindhtech.com

[mak1210]

[codesolutionsstuff]

JavaScript's Lambda and Arrow Functions

The majority of contemporary programming languages support lambda expressions (Python, Ruby, Java…). Simply said, they are expressions that generate functions. First-class functions, which essentially mean sending functions as arguments to other functions or assigning them to variables, are extremely crucial for a programming language to provide. Function expressions in JavaScript prior to ES6 provides us with an anonymous function (a function without a name). var anon = function (a, b) { return a + b }; We now have arrow functions in ES6 that offer a more adaptable syntax as well as some added features and difficulties. // we could write the above example as: var anon = (a, b) => a + b; // or var anon = (a, b) => { return a + b }; // if we only have one parameter we can loose the parentheses var anon = a => a; // and without parameters var () => {} // noop // this looks pretty nice when you change something like: .filter(function (value) {return value % 2 === 0}); // to: .filter(value => value % 2 === 0); The fact that arrow functions lack their own this value is one of their main advantages. This is lexically bound to the scope it is contained in. This suggests that we can bid this awful pattern farewell: class Logger { dumpData(data) { var _this = this; // this dumps data to a file and get the name of the file via a callback dump(data, function (outputFile) { _this.latestLog = outputFile; }); } } // using arrow functions class Logger { dumpData(data) { dump(data, outputFile => this.latestLog = outputFile); } } However, there are a few pitfalls to be aware of: - This should be rather obvious, but since it is lexically bound, there is no way to change it. Neither call() nor apply() will be able to supply a different value for this. - There are no disagreements. (function () {console.log(arguments)})(1, 2); // will output (() => console.log(arguments))(1, 2); - When returning object literals, exercise caution. (() => {foo: 1})() // this will return undefined. 'foo: 1' is interpreted as a statement composed of a label and the literal 1 // the correct way should be wrapping it with parenthesis (() => ({foo: 1}))() // returns Object {foo: 1}

Conclusion

In conclusion, arrow functions are a fantastic addition to the JavaScript language that enable considerably more ergonomic code in a variety of circumstances. They do, however, have advantages and cons, just like any other characteristic. They ought to serve as an additional resource for us. Read the full article

[zenesys]

How to Trigger Lambda Functions Automatically-- Check what are the AWS services that can trigger the lambda function

[winsurtech]

Apart from using the AWS Lambda console directly to create or update the functions, AWS provides a very easy way to do the same stuff using Command Line Interface (CLI) as well. In this blog, we’ll learn the process to create a new Lambda function written in Java using CLI commands. There are a few prerequisites which you need to fulfill before moving on to create the function, such as you must have some knowledge of basic Lambda operations and must be aware of using Lambda console. Also, you will need a command-line terminal or shell to run the CLI commands. Now, let’s get started.

[initialcommit]

Refresher on how to write Anonymous / Lambda Functions in Python, Java, JavaScript, C, and PHP. Follow @initialcommit for more programming content. Check out our website https://initialcommit.io for programming articles, books, live sessions, and how to create your own code-oriented website. #initialcommit #lambda #anonymous #lambdafunction #anonymousfunction #function #python #pythonprogramming #java #javaprogramming #javascript #cprogramming #php #programming #coding #learnprogramming #learncoding #softwaredevelopment https://www.instagram.com/p/CAiRvIKFt9B/?igshid=1t7v4ndu92c4a

[phungthaihy]

AWS Lambda | What is AWS Lambda | AWS Lambda Tutorial for Beginners | Intellipaat http://ehelpdesk.tk/wp-content/uploads/2020/02/logo-header.png [ad_1] Intellipaat AWS training course:... #amazonlambdaexample #amazonlambdafunction #amazonlambdatutorial #amazonwebservicestutorialforbeginners #aws #awscertification #awscertificationtraining #awscertifiedcloudpractitioner #awscertifieddeveloper #awscertifiedsolutionsarchitect #awscertifiedsysopsadministrator #awslambda #awslambdajava #awslambdajavatutorial #awslambdatutorial #awslambdatutorialforbeginners #awsservicestutorial #awstutorialforbeginners #ciscoccna #comptiaa #comptianetwork #comptiasecurity #cybersecurity #ethicalhacking #intellipaat #it #kubernetes #lambdafunctions #lambdalayers #linux #microsoftaz-900 #microsoftazure #networksecurity #serverlesslambda #simplilearn #software #whatisamazonlambda #whatisamazonlambdausedfor #whatisawslambda #windowsserver

[awsexchage]

AutoScalingのライフサイクルフックでStepFunctionsを呼び出して処理を行う http://ift.tt/2H4i5H8

概要

AutoScalingするWebサーバーにCMSサーバーからコンテンツ同期を行っている環境があり、ELBに追加する前にコンテンツ同期が終わっているか確認したかったのでAutoScalingライフサイクルフックでStepFunctionsを呼び出して外部公開前にコンテンツ同期のチェックとライフサイクルアクションを完了させるようにしてみました。

構成図

実装

AutoScaling

コマンドもしくはコンソールからインスタンスの起動 autoscaling:EC2_INSTANCE_LAUNCHING なライフサイクルフックを追加します。 https://docs.aws.amazon.com/ja_jp/autoscaling/ec2/userguide/lifecycle-hooks.html#adding-lifecycle-hooks

Lambda

コンテンツの同期チェックとライフサイクルフックを完了させるLambdaFunctionを作成します。外部にはELB経由で公開しているので、LambdaはVPC内で起動しインスタンスのプライベートIPに確認しに行きます。 確認するURLはスクリプトを使いまわせるようにLambdaの環境変数に書いています。

# -*- coding: utf-8 -*- import boto3 import hashlib import os import requests ec2 = boto3.resource('ec2') autoscaling = boto3.client('autoscaling') def lambda_handler(event, context): """ AutoScalingのCloudWatch Events[EC2 Instance-launch Lifecycle Action]から起動。 コンテンツの同期を確認、完了していればLifecycle Actionを完了させELBに組み込む。 """ print(event) try: instance_id = event['detail']['EC2InstanceId'] instance = ec2.Instance(instance_id) host = os.environ['Host'] headers = {'Host': host} origin_req = {'timeout': 5} replica_req = {'timeout': 5, 'headers': headers} # TOPページをチェック origin_top = requests.get('https://{}/'.format(host), **origin_req) replica_top = requests.get('http://{}/'.format(instance.private_ip_address), **replica_req) # TOPページのコンテンツを比較 top_result = check_content(origin_top, replica_top) if top_result is True: # Lifecycle Actionを完了 print('Content sync is complete.') response = autoscaling.complete_lifecycle_action( LifecycleHookName=event['detail']['LifecycleHookName'], AutoScalingGroupName=event['detail']['AutoScalingGroupName'], LifecycleActionResult='CONTINUE', InstanceId=instance_id ) print(response) else: class ContentUnsyncException(Exception): """ StepFunctionに認識させるコンテンツが同期が完了していない例外 """ pass raise ContentUnsyncException('top_result:{} pre_result:{}'.format(top_result, pre_result)) except Exception as e: print(e) raise e def check_content(origin, replica): origin_hash = hashlib.sha256(origin.text.encode('utf-8')).hexdigest() replica_hash = hashlib.sha256(replica.text.encode('utf-8')).hexdigest() return origin_hash == replica_hash

IAM Roleは AWSLambdaVPCAccessExecutionRole AmazonEC2ReadOnlyAccess とautoscaling:CompleteLifecycleAction あたりを行えるよう許可します。

StepFunctions

Lambdaを呼び出すステートマシンを作成します。 コンテンツ同期に少し時間がかかるのでリトライを設定しています。

{ "Comment": "Check the sync status of content at instance startup.", "StartAt": "CheckContent", "States": { "CheckContent": { "Type": "Task", "Resource": "arn:aws:lambda:${region}:${account_id}:function:check_content", "Retry": [ { "ErrorEquals": [ "ContentUnsyncException", "States.TaskFailed", "States.Timeout" ], "IntervalSeconds": 30, "MaxAttempts": 10, "BackoffRate": 1.0 } ], "End": true } } }

IAM Roleは lambda:InvokeFunction を許可します。

CloudWatchイベント

CloudWatchイベントでAutoScalingのライフサイクルアクションからステートマシンを呼び出すよう設定します。

{ "detail": { "AutoScalingGroupName": [ "${autoscalinggroupname}" ] }, "detail-type": [ "EC2 Instance-launch Lifecycle Action" ], "source": [ "aws.autoscaling" ] }

IAM Roleは states:StartExecution を許可します。 StepFunctionsとCloudWatchはコンソールから作成するとRoleもいい感じのが作成されるかと思います。

実行結果

スケールアウトが発生するとスケールアウトした数だけStepFunctionが動いてコンテンツ同期状況をチェックしてくれます。

参考

Amazon EC2 Auto Scaling ライフサイクルフック

Amazon VPC 内のリソースにアクセスできるように Lambda 関数を構成する

CloudWatch イベント を使用してステートマシンの実行を開始する

Automating AWS Lambda Function Error Handling with AWS Step Functions

元記事はこちら

「AutoScalingのライフサイクルフックでStepFunctionsを呼び出して処理を行う」

March 05, 2018 at 02:00PM

[a-alex-hammer]

Build your own real-time voice translator application with AWS services

Just imagine—you say something in one language, and a tool immediately translates it to another language. Wouldn’t it be even cooler to build your own real-time voice translator application using AWS services? It would be similar to the Babel fish in The Hitchhiker’s Guide to the Galaxy:

“The Babel fish is small, yellow, leech-like—and probably the oddest thing in the universe… If you stick one in your ear, you can instantly understand anything said to you in any form of language.”

Douglas Adams, The Hitchhiker’s Guide to the Galaxy

In this post, I show how you can connect multiple services in AWS to build your own application that works like a bit like the Babel fish.

About this blog post Time to read 15 minutes Time to complete 30 minutes Cost to complete Under $1 Learning level Intermediate (200) AWS services Amazon Polly, Amazon Transcribe, Amazon Translate, AWS Lambda, Amazon CloudFront, Amazon S3

Overview

The heart of this application consists of an AWS Lambda function that connects the following three AI language services:

Amazon Transcribe — This fully managed and continuously trained automatic speech recognition (ASR) service takes in audio and automatically generates accurate transcripts. Amazon Transcribe supports real-time transcriptions, which help achieve near real-time conversion.

Amazon Translate — This neural machine-translation service delivers fast, high-quality, and affordable language translation.

Amazon Polly — This text-to-speech service uses advanced deep learning technologies to synthesize speech that sounds like a human voice.

A diagrammatic representation of how these three services relate is shown in the following illustration.

To make this process a bit easier, you can use an AWS CloudFormation template, which initiates the application. The following diagram shows all the components of this process, which I later describe in detail.

Here’s the flow of service interactions:

Allow access to your site with Amazon CloudFront, which allows you to get an HTTPS link to your page and which is required by some browsers to record audio.

Host your page on Amazon S3, which simplifies the whole solution. This is also the place to save the input audio file recorded in the browser.

Gain secure access to S3 and Lambda from the browser with Amazon Cognito.

Save the input audio file on S3 and invoke a Lambda function. In the input of the function, provide the name of audio file (that you saved earlier in Amazon S3), and pass the source and target language parameters.

Convert audio into text with Amazon Transcribe.

Translate the transcribed text from one language to another with Amazon Translate.

Convert the new translated text into speech with Amazon Polly.

Save the output audio file back to S3 with the Lambda function, and then return the file name to your page (JavaScript invocation). You could return the audio file itself, but for simplicity, save it on S3 and just return its name.

Automatically play the translated audio to the user.

Accelerate the speed of delivering the file with CloudFront.

Getting started

As I mentioned earlier, I created an AWS CloudFormation template to create all the necessary resources.

Sign into the console, and then choose Launch Stack, which launches a CloudFormation stack in your AWS account. The stack launches in the US-East-1 (N. Virginia) Region.

Go through the wizard and create the stack by accepting the default values. On the last step of the wizard, acknowledge that CloudFormation creates IAM After 10–15 minutes, the stack has been created.

In the Outputs section of the stack shown in the following screenshot, you find the following four parameters:

VoiceTranslatorLink—The link to your webpage.

VoiceTranslatorLambda—The name of the Lambda function to be invoked from your web application.

VoiceTranslatorBucket—The S3 bucket where you host your application, and where audio files are stored.

IdentityPoolIdOutput—The identity pool ID, which allows you to securely connect to S3 and Lambda.

Download the following zip file and then unzip it. There are three files inside.

Open the downloaded file named voice-translator-config.js, and edit it based on the four output values in your stack (Step 3). It should then look similar to the following.

var bucketName = 'voicetranslatorapp-voicetranslat……'; var IdentityPoolId = 'us-east-1:535…….'; var lambdaFunction = 'VoiceTranslatorApp-VoiceTranslatorLambda-….';

In the S3 console, open the S3 bucket (created by the CloudFormation template). Upload all three files, including the modified version of voice-translator-config.js.

Testing

Open your application from the link provided in Step 3. In the Voice Translator App interface, perform the following steps to test the process:

Choose a source language.

Choose a target language.

Think of something to say, choose START RECORDING, and start speaking.

When you finish speaking, choose STOP RECORDING and wait a couple of seconds.

If everything worked fine, the application should automatically play the audio in the target language.

Conclusion

As you can see, it takes less than an hour to create your own unique voice translation application, based on the existing, integrated AI language services in AWS. Plus, the whole process is done without a server.

This application currently supports two input languages: US English and US Spanish. However, Amazon Transcribe recently started supporting real-time speech-to-text in British English, French, and Canadian French. Feel free to try to extend your application by using those languages.

To see the source code of the app (including the Lambda function written in JavaScript), you can find it in the voice-translator-app GitHub repo. In addition to using the browser to record your voice, I also used this recorder.js script by Matt Diamond.

About the Author

Tomasz Stachlewski is a Solutions Architect at AWS, where he helps companies of all sizes (from startups to enterprises) in their cloud journey. He is a big believer in innovative technology, such as serverless architecture, which allows companies to accelerate their digital transformation.

        Source link

Source/Repost=> http://technewsdestination.com/build-your-own-real-time-voice-translator-application-with-aws-services/ ** Alex Hammer | Founder and CEO at Ecommerce ROI ** http://technewsdestination.com

[omarkhanca]

xamarin > Serverless Lambdafunction xamarin android. | 2018-11-30T12:02:49.000Z

[codesolutionsstuff]

JavaScript's Lambda and Arrow Functions

The majority of contemporary programming languages support lambda expressions (Python, Ruby, Java…). Simply said, they are expressions that generate functions. First-class functions, which essentially mean sending functions as arguments to other functions or assigning them to variables, are extremely crucial for a programming language to provide. Function expressions in JavaScript prior to ES6 provides us with an anonymous function (a function without a name). var anon = function (a, b) { return a + b }; We now have arrow functions in ES6 that offer a more adaptable syntax as well as some added features and difficulties. // we could write the above example as: var anon = (a, b) => a + b; // or var anon = (a, b) => { return a + b }; // if we only have one parameter we can loose the parentheses var anon = a => a; // and without parameters var () => {} // noop // this looks pretty nice when you change something like: .filter(function (value) {return value % 2 === 0}); // to: .filter(value => value % 2 === 0); The fact that arrow functions lack their own this value is one of their main advantages. This is lexically bound to the scope it is contained in. This suggests that we can bid this awful pattern farewell: class Logger { dumpData(data) { var _this = this; // this dumps data to a file and get the name of the file via a callback dump(data, function (outputFile) { _this.latestLog = outputFile; }); } } // using arrow functions class Logger { dumpData(data) { dump(data, outputFile => this.latestLog = outputFile); } } However, there are a few pitfalls to be aware of: - This should be rather obvious, but since it is lexically bound, there is no way to change it. Neither call() nor apply() will be able to supply a different value for this. - There are no disagreements. (function () {console.log(arguments)})(1, 2); // will output (() => console.log(arguments))(1, 2); - When returning object literals, exercise caution. (() => {foo: 1})() // this will return undefined. 'foo: 1' is interpreted as a statement composed of a label and the literal 1 // the correct way should be wrapping it with parenthesis (() => ({foo: 1}))() // returns Object {foo: 1}

Conclusion

In conclusion, arrow functions are a fantastic addition to the JavaScript language that enable considerably more ergonomic code in a variety of circumstances. They do, however, have advantages and cons, just like any other characteristic. They ought to serve as an additional resource for us. Read the full article

[codesolutionsstuff]

JavaScript's Lambda and Arrow Functions

The majority of contemporary programming languages support lambda expressions (Python, Ruby, Java…). Simply said, they are expressions that generate functions. First-class functions, which essentially mean sending functions as arguments to other functions or assigning them to variables, are extremely crucial for a programming language to provide. Function expressions in JavaScript prior to ES6 provides us with an anonymous function (a function without a name). var anon = function (a, b) { return a + b }; We now have arrow functions in ES6 that offer a more adaptable syntax as well as some added features and difficulties. // we could write the above example as: var anon = (a, b) => a + b; // or var anon = (a, b) => { return a + b }; // if we only have one parameter we can loose the parentheses var anon = a => a; // and without parameters var () => {} // noop // this looks pretty nice when you change something like: .filter(function (value) {return value % 2 === 0}); // to: .filter(value => value % 2 === 0); The fact that arrow functions lack their own this value is one of their main advantages. This is lexically bound to the scope it is contained in. This suggests that we can bid this awful pattern farewell: class Logger { dumpData(data) { var _this = this; // this dumps data to a file and get the name of the file via a callback dump(data, function (outputFile) { _this.latestLog = outputFile; }); } } // using arrow functions class Logger { dumpData(data) { dump(data, outputFile => this.latestLog = outputFile); } } However, there are a few pitfalls to be aware of: - This should be rather obvious, but since it is lexically bound, there is no way to change it. Neither call() nor apply() will be able to supply a different value for this. - There are no disagreements. (function () {console.log(arguments)})(1, 2); // will output (() => console.log(arguments))(1, 2); - When returning object literals, exercise caution. (() => {foo: 1})() // this will return undefined. 'foo: 1' is interpreted as a statement composed of a label and the literal 1 // the correct way should be wrapping it with parenthesis (() => ({foo: 1}))() // returns Object {foo: 1}

Conclusion

In conclusion, arrow functions are a fantastic addition to the JavaScript language that enable considerably more ergonomic code in a variety of circumstances. They do, however, have advantages and cons, just like any other characteristic. They ought to serve as an additional resource for us. Read the full article

[phungthaihy]

AWS Certification Training Free AWS Tutorials: AWS Lambda Overview and How to Create Simple Function http://ehelpdesk.tk/wp-content/uploads/2020/02/logo-header.png [ad_1] In this FREE AWS video tutorial,... #amazonwebservices #aws #awsamazon #awscertification #awscertificationtraining #awscertified #awscertifiedcloudpractitioner #awscertifieddeveloper #awscertifiedsolutionsarchitect #awscertifiedsysopsadministrator #awscloud #awscloudcomputing #awsfree #awshands-onlabs #awshowto #awslambda #awslambdanode10 #awspracticelabs #awstraining #awstutorialsforbeginners #ciscoccna #cloudcomputing #cloudservices #cloudtechnology #comptiaa #comptianetwork #comptiasecurity #cybersecurity #ethicalhacking #it #kubernetes #lambdafunction #lambdanodejsexample #linux #microsoftaz-900 #microsoftazure #networksecurity #serverlessframework #software #solutionsarchitect #webamazonservices #whatisaws #windowsserver