Лямбда что это: Недопустимое название | Энциклопедия Half-Life

Бессерверные вычисления – Возможности AWS Lambda – Amazon Web Services

AWS Lambda – это сервис бессерверных вычислений, который запускает программный код в ответ на определенные события и отвечает за автоматическое выделение необходимых вычислительных ресурсов. В перечень событий входят изменения в состоянии или обновление, например, когда пользователь помещает товар в корзину на веб-сайте интернет-коммерции. AWS Lambda можно использовать для расширения возможностей других сервисов AWS с помощью специальной логики или для создания собственных серверных сервисов с применением возможностей масштабирования, производительности и безопасности AWS. AWS Lambda автоматически запускает программный код в ответ на различные события, такие как HTTP‑запросы через Amazon API Gateway, изменение объектов в корзинах Amazon Simple Storage Service (Amazon S3), обновление таблиц в Amazon DynamoDB или смена состояний в AWS Step Functions.

Lambda запускает код в высокопроизводительной вычислительной среде и полностью выполняет администрирование вычислительных ресурсов. В том числе обслуживание сервера и операционной системы, выделение ресурсов и автоматическое масштабирование, развертывание исправлений кода и системы безопасности, а также мониторинг кода и ведение журналов. От вас требуется только предоставить программный код.

Расширьте возможности сервисов AWS с помощью собственного программного кода

AWS Lambda позволяет добавлять свой код к ресурсам AWS, например к корзинам сервиса Amazon S3 и таблицам Amazon DynamoDB. В результате можно просто выполнять нужные операции с данными на этапе их вхождения или перемещения в рамках облака.

Начать работу с AWS Lambda совсем не сложно. Сначала требуется создать необходимые функции, загрузив свой код (или написав его непосредственно в консоли Lambda), а также задав объем памяти, период ожидания и роль AWS Identity and Access Management (IAM). Затем необходимо указать ресурс AWS, который будет триггером для функции: конкретную корзину сервиса Amazon S3, таблицу Amazon DynamoDB или поток Amazon Kinesis. Зафиксировав изменение ресурса, Lambda выполнит настроенную функцию, запустит вычислительные ресурсы, необходимые для обработки поступающих запросов, и будет управлять ими.

Создавайте собственные серверные сервисы

AWS Lambda можно использовать для создания новых сервисов приложений, которые будут активироваться по требованию с помощью интерфейса прикладного программирования (API) Lambda или специальных адресов API, созданных с использованием Amazon API Gateway. Специальные события обрабатываются с помощью Lambda, а не на устройстве клиента, позволяя не зависеть от пользовательских операционных систем, снижая энергопотребление на стороне клиента и упрощая установку обновлений.

Использование собственного кода

Для работы с AWS Lambda не нужно осваивать новые языки, инструменты или инфраструктуру. Сервис работает с любыми сторонними библиотеками, даже встроенными. Кроме того, можно упаковать любой код (платформу, SDK, библиотеку и т. д.) как уровень Lambda, чтобы использовать его с разными функциями и управлять им. Lambda имеет встроенную поддержку Java, Go, PowerShell, Node.js, C#, Python и Ruby, а также предоставляет API среды выполнения для создания функций с использованием любых других языков программирования.

Полностью автоматизированное администрирование

Благодаря тщательному управлению инфраструктурой AWS Lambda код исполняется в высокопроизводительной, отказоустойчивой среде, что позволяет сосредоточить свои усилия на разработке разнообразных серверных сервисов. Lambda избавляет от забот по обновлению серверной операционной системы (ОС), а также проблем, связанных с расширением существующих или вводом в эксплуатацию новых серверов по мере роста нагрузки. AWS Lambda обеспечивает эффективное развертывание кода, выполняет задачи администрирования, технического обслуживания, исправления уязвимостей системы и обеспечивает возможность мониторинга и ведения журналов средствами Amazon CloudWatch.

Встроенная отказоустойчивость

AWS Lambda поддерживает необходимые объемы вычислительных ресурсов в нескольких зонах доступности (AZ) в каждом из регионов AWS, защищая код от неисправностей отдельных единиц оборудования или сбоев в работе центров обработки данных (ЦОД). AWS Lambda и функции, работающие в рамках этого сервиса, обеспечивают предсказуемую и надежную операционную производительность. Сервис AWS Lambda разработан для обеспечения высокой доступности как самого сервиса, так и исполняемых им функций. Сервис работает без плановых простоев и перерывов на обслуживание.

Упаковывание и развертывание функций как образов контейнеров

AWS Lambda поддерживает упаковывание и развертывание функций в виде образов контейнеров, что упрощает для клиентов создание приложений на основе Lambda с помощью известных инструментов, рабочих процессов и зависимостей для образов контейнеров. К другим преимуществам работы с Lambda для клиентов относятся простота эксплуатации, автоматическое масштабирование со временем запуска менее секунды, высокая доступность, модель оплаты по мере использования и встроенная интеграция с более чем 200 сервисами AWS и приложениями «ПО как услуга» (SaaS). Корпоративные клиенты могут использовать согласованный набор инструментов как со своими приложениями Lambda, так и с контейнерными приложениями, упрощая необходимое централизованное управление, такое как сканирование безопасности и подпись образов.

Автоматическое масштабирование

AWS Lambda вызывает код только тогда, когда это необходимо, и автоматически масштабирует ресурсы в соответствии с объемом поступающих запросов без какой бы то ни было ручной настройки. Количество обрабатываемых запросов не ограничено. AWS Lambda обычно начинает запуск вашего кода в течение миллисекунд после того, как произошло событие. Так как Lambda масштабируется автоматически, производительность остается стабильно высокой при увеличении частоты событий. Поскольку код исполняется без сохранения состояний, Lambda может создавать необходимое количество инстансов без долгих процедур развертывания или задержек из‑за настройки.

Подключение к реляционным базам данных

Используйте Amazon RDS Proxy, чтобы воспользоваться полностью управляемыми пулами подключения для работы с реляционными базами данных. С помощью RDS Proxy можно эффективно управлять тысячами одновременных подключений к реляционным базам данных. Это позволяет легко разрабатывать высокомасштабируемые, безопасные и бессерверные приложения на основе Lambda, которые подключаются к реляционным базам данных. На данный момент RDS Proxy поддерживает базы данных MySQL и Aurora. RDS Proxy для бессерверных приложений можно настроить на консоли Amazon RDS или на консоли AWS Lambda.

Точный контроль за производительностью

Provisioned Concurrency позволяет лучше контролировать производительность бессерверных приложений. Когда эта возможность включена, функции находятся в инициализированном состоянии и готовы к быстрому реагированию в пределах ста миллисекунд. Provisioned Concurrency идеально подходит для работы с приложениями AWS Lambda, которым требуется больший контроль за временем запуска функций. С легкостью настраивайте требуемые для приложения параллельные операции. Увеличивайте или уменьшайте масштаб и даже отключайте операции при необходимости. Воспользуйтесь Provisioned Concurrency, чтобы обеспечить стабильную производительность приложений, которые должны работать с минимальными задержками, без необходимости менять код или управлять вычислительными ресурсами.

Подключение к общим файловым системам

Использование Amazon Elastic File System (EFS) для AWS Lambda позволяет безопасно считывать, записывать и сохранять большие объемы данных с низкой задержкой при работе в любом масштабе. Писать код и загружать данные во временное хранилище для их последующей обработки не требуется. Это экономит время и упрощает код приложений, позволяя сосредоточиться на бизнес‑логике. EFS для Lambda идеально подходит для целого ряда примеров использования, включая обработку или резервное копирование больших объемов данных, а также загрузку больших справочных файлов или моделей. Система также позволяет совершать обмен файлами между бессерверными инстансами или контейнерными приложениями и даже запускать вывод машинного обучения (ML) с помощью EFS для AWS Lambda.

Запуск кода в ответ на запросы Amazon CloudFront

С помощью возможности Lambda@Edge AWS Lambda может запускать соответствующий код в местоположениях AWS по всему миру в ответ на события Amazon CloudFront, например запросы контента от серверов источника или посетителей либо в обратном направлении. Это упрощает предоставление конечным клиентам более качественного, индивидуально настроенного контента с меньшей задержкой.  

Оркестрация множества функций

Создавайте рабочие процессы AWS Step Functions, чтобы координировать исполнение множества функций AWS Lambda для решения сложных и продолжительных задач. Сервис Step Functions позволяет определять рабочие процессы, которые активируют набор функций Lambda с помощью последовательных, параллельных, разветвленных списков операций, в том числе с возможностями обработки ошибок. С помощью Step Functions и Lambda можно создавать длительные структурированные процессы для приложений и серверов.

Интегрированная модель безопасности

Встроенный пакет средств разработки ПО (SDK) AWS Lambda интегрируется с AWS Identity and Access Management (IAM), чтобы обеспечить безопасный доступ других сервисов AWS к коду. AWS Lambda по умолчанию запускает ваш код в Amazon Virtual Private Cloud (VPC). При необходимости можно настроить доступ к ресурсам AWS Lambda за пределами собственного VPC, чтобы использовать пользовательские группы безопасности и сетевые списки контроля доступа. Благодаря этому функция Lambda получает безопасный доступ к ресурсам VPC. AWS Lambda соответствует требованиям SOC, HIPAA, PCI и ISO. Актуальную информацию о сертификации Lambda и соответствии требованиям см. на странице Сервисы в программе соответствия требованиям.

Средства контроля доверия и целостности

Подписание кода для AWS Lambda позволяет обеспечить развертывание в ваших функциях Lambda только неизменного кода от подтвержденных разработчиков. Просто создавайте артефакты кода с цифровой подписью и настраивайте функции Lambda для проверки подписей при развертывании. Благодаря этому можно повысить скорость и гибкость вашей разработки приложений даже в больших группах разработчиков, обеспечивая при этом высокие стандарты безопасности.

Оплата по факту использования

Оплата за использование AWS Lambda начисляется за стабильную пропускную способность или время исполнения, а не за количество используемых серверов. Используя функции Lambda, вы платите только за выполненные запросы и время вычислений, необходимое для запуска кода. Счет за использование выставляется с точностью до одной миллисекунды, благодаря чему автоматическое масштабирование от нескольких запросов в день до тысяч запросов в секунду становится простым и экономичным. При использовании Provisioned Concurrency вы оплачиваете указанное вами количество параллельных операций за выбранный период времени. Когда функция, для которой настроен сервис Provisioned Concurrency, включена и выполняется, вы также платите за запросы и время выполнения. Подробная информация о ценах доступна на странице цен на AWS Lambda.

Гибкая модель распределения ресурсов

Задайте для своих функций необходимый объем памяти, и AWS Lambda выделит пропорциональное количество ресурсов ЦПУ, пропускной способности сети и дисковых операций чтения / записи (I/O).

Интеграция Lambda с привычными рабочими инструментами

Расширения AWS Lambda позволяют с легкостью выполнять интеграцию с привычными инструментами для мониторинга, наблюдения, обеспечения безопасности и управления. Lambda вызывает функцию в среде выполнения, обеспечивая безопасное и изолированную среду для выполнения кода функции. Расширения Lambda запускаются в среде выполнения Lambda, вместе с кодом функции. Расширения Lambda могут использовать API телеметрии AWS Lambda для сбора подробной диагностической информации, такой как журналы, метрики и данные отслеживания, непосредственно из Lambda и отправлять их в выбранное вами место назначения. В среде выполнения Lambda также можно просто интегрировать агенты безопасности, оказывающие минимальное влияние на производительность функций.

Обеспечьте до 34 % лучшую производительность благодаря функциям на базе Graviton2

Функции AWS Lambda, работающие на Graviton2 с архитектурой процессора Arm от AWS, обеспечивают производительность до 34 % лучше, чем у функций на процессорах x86. Это относится к различным бессерверным рабочим нагрузкам, таким как веб- и мобильные серверы, обработка данных и мультимедиа. Функции Graviton2 дают меньшую задержку, производительность на 19 % выше, сниженную на 20 % стоимость и наибольшую энергоэффективность, доступную в AWS. Благодаря этому их можно использовать для критически важных бессерверных приложений.

Подробнее о ценах на AWS Lambda

Перейти на страницу цен

Готовы начать?

Регистрация

Возникли дополнительные вопросы?

Связаться с нами

Вход в Консоль

Подробнее об AWS

• Что такое AWS?
• Что такое облачные вычисления?
• Инклюзивность, многообразие и равенство AWS
• Что такое DevOps?
• Что такое контейнер?
• Что такое озеро данных?
• Безопасность облака AWS
• Новые возможности
• Блоги
• Пресс‑релизы

Ресурсы для работы с AWS

• Начало работы
• Обучение и сертификация
• Портфолио решений AWS
• Центр архитектурных решений
• Вопросы и ответы по продуктам и техническим темам
• Отчеты аналитиков
• Партнерская сеть AWS

Разработчики на AWS

• Центр разработчика
• Пакеты SDK и инструментарий
• . NET на AWS
• Python на AWS
• Java на AWS
• PHP на AWS
• JavaScript на AWS

Поддержка

• Связаться с нами
• Работа в AWS
• Обратиться в службу поддержки
• Центр знаний
• AWS re:Post
• Обзор AWS Support
• Юридическая информация

Amazon.com – работодатель равных возможностей. Мы предоставляем равные права
представителям меньшинств, женщинам, лицам с ограниченными возможностями, ветеранам боевых действий и представителям любых гендерных групп любой сексуальной ориентации независимо от их возраста.

Поддержка AWS для Internet Explorer заканчивается 07/31/2022. Поддерживаемые браузеры: Chrome, Firefox, Edge и Safari.
Подробнее »

Лямбды — Kotlin

В Kotlin функции являются функциями первого класса. Это значит,
что они могут храниться в переменных и структурах данных, передаваться в качестве аргументов и возвращаться из других
функций высшего порядка. Вы можете работать с функциями любым способом, который возможен
для других нефункциональных значений.

Чтобы это облегчить, Kotlin, как статически типизированный язык программирования, использует семейство
функциональных типов для представления функций и предоставляет набор специализированных языковых
конструкций, таких как лямбда-выражения.

Функции высшего порядка

Функция высшего порядка — это функция, которая принимает функции как параметры, или возвращает функцию в качестве результата.

Хорошим примером такой функции является идиома функционального программирования fold для коллекций, которая
принимает начальное значение — accumulator вместе с комбинирующей функцией и строит возвращаемое значение,
последовательно комбинируя текущее значение accumulator с каждым элементом коллекции, заменяя значение accumulator.

fun <T, R> Collection<T>.fold(
    initial: R,
    combine: (acc: R, nextElement: T) -> R
): R {
    var accumulator: R = initial
    for (element: T in this) {
        accumulator = combine(accumulator, element)
    }
    return accumulator
}

В приведённом выше коде параметр combine имеет функциональный тип (R, T) -> R, поэтому он
принимает функцию, которая принимает два аргумента типа R и T и возвращает значение типа R. Он
вызывается внутри цикла for и присваивает accumulator возвращаемое значение.

Чтобы вызвать fold, вы должны передать ему экземпляр функционального типа в качестве
аргумента и лямбда-выражение (описание ниже). Лямбда-выражения часто
используются в качестве параметра функции высшего порядка.

fun main() {
    val items = listOf(1, 2, 3, 4, 5)
    // Лямбда - это блок кода, заключенный в фигурные скобки.
    items.fold(0, {
        // Если у лямбды есть параметры, то они указываются перед знаком '->'
        acc: Int, i: Int ->
        print("acc = $acc, i = $i, ")
        val result = acc + i
        println("result = $result")
        // Последнее выражение в лямбде считается возвращаемым значением:
        result
    })
    // Типы параметров в лямбде необязательны, если они могут быть выведены:
    val joinedToString = items.fold("Elements:", { acc, i -> acc + " " + i })
    // Ссылки на функции также могут использоваться для вызовов функций высшего порядка:
    val product = items. fold(1, Int::times)
    println("joinedToString = $joinedToString")
    println("product = $product")
}

Функциональные типы

Kotlin использует семейство функциональных типов, таких как (Int) -> String, для объявлений, которые являются частью
функций: val onClick: () -> Unit = ....

Эти типы имеют специальные обозначения, которые соответствуют сигнатурам функций, то есть их параметрам и возвращаемым значениям:

• У всех функциональных типов есть список с типами параметров, заключенный в скобки, и возвращаемый тип: (A, B) -> C
  обозначает тип, который предоставляет функции два принятых аргумента типа A и B, а также возвращает значение типа C.
  Список с типами параметров может быть пустым, как, например, в () -> A. Возвращаемый тип
  Unit не может быть опущен;

• У функциональных типов может быть дополнительный тип — получатель (ориг. : receiver), который указывается в
  объявлении перед точкой: тип A.(B) -> C описывает функции, которые могут быть вызваны для объекта-получателя A с
  параметром B и возвращаемым значением C. Литералы функций с объектом-приёмником
  часто используются вместе с этими типами;

• Останавливаемые функции (ориг.: suspending functions)
  принадлежат к особому виду функциональных типов, у которых в объявлении присутствует модификатор suspend, например,
  suspend () -> Unit или suspend A.(B) -> C.

Объявление функционального типа также может включать именованные параметры: (x: Int, y: Int) -> Point.
Именованные параметры могут быть использованы для описания смысла каждого из параметров.

Чтобы указать, что функциональный тип может быть nullable,
используйте круглые скобки: ((Int, Int) -> Int)?.

При помощи круглых скобок функциональные типы можно объединять: (Int) -> ((Int) -> Unit).

Стрелка в объявлении является правоассоциативной (ориг.: right-associative), т.е. объявление
(Int) -> (Int) -> Unit эквивалентно объявлению из предыдущего примера, а не ((Int) -> (Int)) -> Unit.

Вы также можете присвоить функциональному типу альтернативное имя, используя псевдонимы типов.

typealias ClickHandler = (Button, ClickEvent) -> Unit

Создание функционального типа

Существует несколько способов получить экземпляр функционального типа:

• Используя блок с кодом внутри функционального литерала в одной из форм:

  • лямбда-выражение: { a, b -> a + b },
  • анонимная функция: fun(s: String): Int { return s.toIntOrNull() ?: 0 }

  Литералы функций с объектом-приёмником могут использоваться как значения функциональных типов с получателем.

• Используя вызываемую ссылку на существующее объявление:

  • функции верхнего уровня, локальной функции, функции-члена или функции-расширения: ::isOdd, String::toInt,
  • свойства верхнего уровня, члена или свойства-расширения: List<Int>::size,
  • конструктора: ::Regex

  К ним относятся привязанные вызываемые ссылки, которые указывают на член конкретного экземпляра: foo::toString.

• Используя экземпляр пользовательского класса, который реализует функциональный тип в качестве интерфейса:

class IntTransformer: (Int) -> Int {
    override operator fun invoke(x: Int): Int = TODO()
}
val intFunction: (Int) -> Int = IntTransformer()

При достаточной информации компилятор может самостоятельно вывести функциональный тип для переменной.

val a = { i: Int -> i + 1 } // Выведенный тип - (Int) -> Int

Небуквальные (ориг.: non-literal) значения функциональных типов с и без получателя являются взаимозаменяемыми,
поэтому получатель может заменить первый параметр, и наоборот. Например, значение типа (A, B) -> C может быть передано
или назначено там, где ожидается A.(B) -> C, и наоборот.

fun main() {
    val repeatFun: String.(Int) -> String = { times -> this.repeat(times) }
    val twoParameters: (String, Int) -> String = repeatFun // OK
    fun runTransformation(f: (String, Int) -> String): String {
        return f("hello", 3)
    }
    val result = runTransformation(repeatFun) // OK
    println("result = $result")
}

Обратите внимание, что функциональный тип без получателя выводится по умолчанию, даже если переменная инициализируется
со ссылкой на функцию-расширение. Чтобы это изменить, укажите тип переменной явно.

Вызов экземпляра функционального типа

Значение функционального типа может быть вызвано с помощью оператора invoke(...):
f.invoke(x) или просто f(x).

Если значение имеет тип получателя, то объект-приёмник должен быть передан в качестве первого аргумента. Другой способ
вызвать значение функционального типа с получателем — это добавить его к объекту-приёмнику, как если бы это была
функция-расширение: 1.foo(2).

Пример:

fun main() {
    val stringPlus: (String, String) -> String = String::plus
    val intPlus: Int.(Int) -> Int = Int::plus
    println(stringPlus.invoke("<-", "->"))
    println(stringPlus("Hello, ", "world!"))
    println(intPlus.invoke(1, 1))
    println(intPlus(1, 2))
    println(2.intPlus(3)) // вызывается как функция-расширение
}

Встроенные функции

Иногда выгодно улучшить производительность функций высшего порядка, используя
встроенные функции (ориг. : inline functions).

Лямбда-выражения и анонимные функции

Лямбда-выражения и анонимные функции — это «функциональный литерал», то есть необъявленная функция, которая немедленно
используется в качестве выражения. Рассмотрим следующий пример:

max(strings, { a, b -> a.length < b.length })

Функция max является функцией высшего порядка, потому что она принимает функцию в качестве второго аргумента.
Этот второй аргумент является выражением, которое в свою очередь есть функция, то есть функциональный литерал.
Как функция он эквивалентен объявлению:

fun compare(a: String, b: String): Boolean = a.length < b.length

Синтаксис лямбда-выражений

Полная синтаксическая форма лямбда-выражений может быть представлена следующим образом:

val sum: (Int, Int) -> Int = { x: Int, y: Int -> x + y }

• Лямбда-выражение всегда заключено в скобки {...};
• Объявление параметров при таком синтаксисе происходит внутри этих скобок и может включать в себя аннотации типов;
• Тело функции начинается после знака ->;
• Если тип возвращаемого значения не Unit, то в качестве возвращаемого типа принимается последнее (а возможно и
  единственное) выражение внутри тела лямбды.

Если вы вынесите все необязательные объявления, то, что останется, будет выглядеть следующим образом:

val sum = { x: Int, y: Int -> x + y }

Передача лямбды в качестве последнего параметра

В Kotlin существует соглашение: если последний параметр функции является функцией, то лямбда-выражение, переданное в
качестве соответствующего аргумента, может быть вынесено за круглые скобки.

val product = items.fold(1) { acc, e -> acc * e }

Такой синтаксис также известен как trailing lambda.

Когда лямбда-выражение является единственным аргументом функции, круглые скобки могут быть опущены.

run { println("...") }

it: неявное имя единственного параметра

Очень часто лямбда-выражение имеет только один параметр.

Если компилятор способен самостоятельно определить сигнатуру, то объявление параметра можно опустить вместе с ->.
Параметр будет неявно объявлен под именем it.

ints. filter { it > 0 } // этот литерал имеет тип '(it: Int) -> Boolean'

Возвращение значения из лямбда-выражения

Вы можете вернуть значение из лямбды явно, используя оператор return.
Либо неявно будет возвращено значение последнего выражения.

Таким образом, два следующих фрагмента равнозначны:

ints.filter {
    val shouldFilter = it > 0
    shouldFilter
}
ints.filter {
    val shouldFilter = it > 0
    return@filter shouldFilter
}

Это соглашение, вместе с передачей лямбда-выражения вне скобок, позволяет писать код в
стиле LINQ.

strings.filter { it.length == 5 }.sortedBy { it }.map { it.uppercase() }

Символ подчеркивания для неиспользуемых переменных

Если параметр лямбды не используется, то разрешено его имя заменить на символ подчёркивания.

map.forEach { _, value -> println("$value!") }

Деструктуризация в лямбдах

Деструктуризация в лямбдах описана в Деструктурирующие объявления.

Анонимные функции

Единственной особенностью синтаксиса лямбда-выражений, о которой ещё не было сказано, является способность определять и
назначать возвращаемый функцией тип. В большинстве случаев в этом нет особой необходимости, потому что он может быть
вычислен автоматически. Однако, если у вас есть потребность в определении возвращаемого типа, вы можете воспользоваться
альтернативным синтаксисом: анонимной функцией.

fun(x: Int, y: Int): Int = x + y

Объявление анонимной функции выглядит очень похоже на обычное объявление функции, за исключением того, что её имя опущено.
Тело такой функции может быть описано и выражением (как показано выше), и блоком.

fun(x: Int, y: Int): Int {
    return x + y
}

Параметры функции и возвращаемый тип обозначаются таким же образом, как в обычных функциях, за исключением того, что тип
параметра может быть опущен, если его значение следует из контекста.

ints.filter(fun(item) = item > 0)

Аналогично и с типом возвращаемого значения: он вычисляется автоматически для функций-выражений или же должен быть явно
определён (если не является типом Unit) для анонимных функций с блоком в качестве тела.

Обратите внимание, что параметры анонимных функций всегда заключены в круглые скобки (...). Приём, позволяющий
оставлять параметры вне скобок, работает только с лямбда-выражениями.

Одним из отличий лямбда-выражений от анонимных функций является поведение оператора return (non-local returns).
Слово return, не имеющее метки (@), всегда возвращается из функции, объявленной ключевым словом fun. Это означает,
что return внутри лямбда-выражения возвратит выполнение к функции, включающей в себя это лямбда-выражение. Внутри
анонимных функций оператор return, в свою очередь, выйдет, собственно, из анонимной функции.

Замыкания

Лямбда-выражение или анонимная функция (так же, как и локальная функция или
анонимные объекты) имеет доступ к своему замыканию, то есть к переменным,
объявленным вне этого выражения или функции. Переменные, захваченные в замыкании, могут быть изменены в лямбде.

var sum = 0
ints.filter { it > 0 }.forEach {
    sum += it
}
print(sum)

Литералы функций с объектом-приёмником

Функциональные типы с получателем, такие как A.(B) -> C, могут быть вызваны с помощью особой
формы – литералов функций с объектом-приёмником.

Как было сказано выше, Kotlin позволяет вызывать экземпляр функционального типа с
получателем, предоставляющим объект-приёмник.

Внутри тела литерала объект-приёмник, переданный при вызове функции, становится неявным this, поэтому вы можете
получить доступ к членам этого объекта-приёмника без каких-либо дополнительных определителей, а обращение к самому
объекту-приёмнику осуществляется с помощью выражения this.

Это схоже с принципом работы функций-расширений, которые позволяют получить доступ к членам
объекта-приёмника внутри тела функции.

Ниже приведён пример литерала с получателем вместе с его типом, где plus вызывается для объекта-приёмника:

val sum: Int. (Int) -> Int = { other -> plus(other) }

Синтаксис анонимной функции позволяет вам явно указать тип приёмника. Это может быть полезно в случае, если вам нужно
объявить переменную типа нашей функции для использования в дальнейшем.

val sum = fun Int.(other: Int): Int = this + other

Лямбда-выражения могут быть использованы как литералы функций с приёмником, когда тип приёмника может быть выведен из контекста.
Один из самых важных примеров их использования это типобезопасные строители (ориг.: type-safe builders).

class HTML {
    fun body() { ... }
}
fun html(init: HTML.() -> Unit): HTML {
    val html = HTML() // создание объекта-приёмника
    html.init()       // передача приёмника в лямбду
    return html
}
html {     // лямбда с приёмником начинается тут
    body() // вызов метода объекта-приёмника
}

Что такое AWS Lambda? — AWS Lambda

AWS Lambda — это служба вычислений, которая позволяет запускать код без предоставления серверов или управления ими. Lambda запускает ваш код
в высокодоступной вычислительной инфраструктуре и выполняет все администрирование вычислительных ресурсов,
включая обслуживание серверов и операционных систем, выделение ресурсов и автоматическое масштабирование, а также
протоколирование. С помощью Lambda вы можете запускать код практически для любого типа приложения или серверной службы. Все, что вам нужно сделать
предоставляет ваш код на одном из языков, поддерживаемых Lambda.

Вы организуете свой код в функции Lambda. Lambda запускает вашу функцию только при необходимости и автоматически масштабируется,
от нескольких запросов в день до тысяч в секунду. Вы платите только за потребляемое вычислительное время — плата не взимается, когда ваш код не выполняется. Чтобы получить больше информации,
см. Цены на AWS Lambda.

Lambda — это высокодоступная служба. Дополнительные сведения см. в Соглашении об уровне обслуживания AWS Lambda.

Примечание

В Руководстве разработчика AWS Lambda предполагается, что у вас есть опыт кодирования, компиляции и развертывания программ.
используя один из языков, поддерживаемых Lambda.

Когда использовать Lambda

Lambda — идеальная вычислительная служба для многих сценариев приложений, если вы можете запускать код своего приложения.
используя стандартную среду выполнения Lambda и ресурсы, предоставляемые Lambda. Например, вы можете использовать Lambda для:

• Обработка файлов: Используйте Amazon Simple Storage Service (Amazon S3) для запуска обработки данных Lambda в режиме реального времени после загрузки.

• Потоковая обработка: Используйте Lambda и Amazon Kinesis для обработки потоковых данных в режиме реального времени для отслеживания активности приложений, обработки транзакций, анализа потока посещений, очистки данных, фильтрации журналов, индексирования, анализа социальных сетей, данных устройств Интернета вещей (IoT). телеметрия и измерение.

• Веб-приложения: Объедините Lambda с другими сервисами AWS для создания мощных веб-приложений, которые автоматически масштабируются вверх и вниз и работают в высокодоступной конфигурации в нескольких центрах обработки данных.

• Бэкенды IoT: Создавайте бессерверные бэкенды с помощью Lambda для обработки веб-запросов, мобильных запросов, запросов IoT и сторонних API.

• Мобильные серверные части: Создавайте серверные части с помощью Lambda и Amazon API Gateway для аутентификации и обработки запросов API. Используйте AWS Amplify, чтобы легко интегрировать серверную часть с внешними интерфейсами iOS, Android, Web и React Native.

При использовании Lambda вы несете ответственность только за свой код. Lambda управляет вычислительным парком, который предлагает
баланс памяти, ЦП, сети и других ресурсов для запуска вашего кода. Поскольку Lambda управляет этими ресурсами, вы
не может войти в вычислительные экземпляры или настроить операционную систему на предоставленном
время выполнения. Lambda выполняет операционную и административную деятельность от вашего имени, включая управление
мощности, мониторинга и регистрации ваших функций Lambda.

Если вам необходимо управлять собственными вычислительными ресурсами, у AWS есть другие вычислительные сервисы, соответствующие вашим потребностям. За
пример:

• Amazon Elastic Compute Cloud (Amazon EC2) предлагает на выбор широкий спектр типов инстансов EC2. Это позволяет настроить
  операционные системы, настройки сети и безопасности, а также весь программный стек. Вы несете ответственность за
  выделение ресурсов, мониторинг работоспособности и производительности парка, а также использование зон доступности для устранения сбоев
  толерантность.

• AWS Elastic Beanstalk позволяет развертывать и масштабировать приложения в Amazon EC2. Вы сохраняете
  владение и полный контроль над базовыми экземплярами EC2.

Функции Lambda

Следующие ключевые функции помогают разрабатывать приложения Lambda, которые являются масштабируемыми, безопасными и простыми в использовании.
расширяемый:

Управление параллелизмом и масштабированием

Параллелизм и средства управления масштабированием
такие как ограничения параллелизма и обеспеченный параллелизм, дают вам
детальный контроль над масштабированием и скоростью отклика ваших производственных приложений.

Функции, определенные как образы контейнеров

Используйте предпочитаемые вами инструменты для работы с образами контейнеров, рабочие процессы и
зависимости для создания, тестирования и развертывания функций Lambda.

Подпись кода

Подписание кода

для Lambda обеспечивает доверие и целостность
элементы управления, которые позволяют вам убедиться, что только неизмененный код, опубликованный утвержденными разработчиками, развернут в
ваши лямбда-функции.

Лямбда-удлинители

Вы можете использовать расширения Lambda для расширения возможностей Lambda.
функции. Например, используйте расширения, чтобы упростить интеграцию Lambda с вашими любимыми инструментами для
мониторинг, наблюдаемость, безопасность и управление.

Схемы функций

Схема функции содержит пример кода, показывающий, как использовать Lambda с другими сервисами AWS или
сторонние приложения. Чертежи включают образцы кода и предустановки конфигурации функций для Node.js и
Среды выполнения Python.

Доступ к базе данных

Прокси базы данных управляет пулом подключений к базе данных
и передает запросы от функции. Это позволяет функции достигать высокого уровня параллелизма без
исчерпание соединений с базой данных.

Доступ к файловым системам

Вы можете настроить функцию для подключения файла Amazon Elastic File System (Amazon EFS).
системы в локальный каталог. С помощью Amazon EFS ваш функциональный код может получать доступ к общим ресурсам и изменять их.
безопасно и с высокой степенью параллелизма.

Начало работы с Lambda

Для эффективной работы с Lambda необходимы опыт программирования и знания в следующих областях:

• ОС и команды Linux, а также такие понятия, как процессы, потоки и права доступа к файлам.

• Знакомство с сервисами и концепциями безопасности: AWS Identity and Access Management (IAM) и принципы управления доступом, а также
  Служба управления ключами AWS (AWS KMS) и инфраструктура открытых ключей.

• Концепции облачных вычислений и концепции IP-сетей (для общедоступных и частных сетей).

• Концепции распределенных вычислений, такие как очереди, обмен сообщениями, уведомления и
  параллелизм.

Если вы впервые пользуетесь Lambda, мы рекомендуем вам прочитать обзор продукта Lambda, а затем выполнить упражнение «Начало работы».

Javascript отключен или недоступен в вашем браузере.

Чтобы использовать документацию Amazon Web Services, должен быть включен Javascript. Инструкции см. на страницах справки вашего браузера.

Условные обозначения документов

Начало работы

Концепции Lambda — AWS Lambda

Lambda запускает экземпляры вашей функции для обработки событий. Вы можете вызвать свою функцию напрямую, используя Lambda
API, или вы можете настроить сервис или ресурс AWS для вызова вашей функции.

Концепции

• Function
• Trigger
• Event
• Execution environment
• Instruction set architecture
• Deployment package
• Runtime
• Layer
• Extension
• Concurrency
• Qualifier
• Destination

Function

A функция — это ресурс, который вы можете вызывать для запуска своего кода в Lambda. Функция имеет
код для обработки событий, которые вы передаете в функцию или
которые другие сервисы AWS отправляют функции.

Дополнительные сведения см. в разделе Настройка функций AWS Lambda.

Триггер

Триггер — это ресурс или конфигурация, которая вызывает функцию Lambda. Триггеры включают
Сервисы AWS, которые можно настроить для вызова функции и события
сопоставления источников. Сопоставление источника событий — это ресурс в Lambda, который считывает элементы из потока или очереди.
и вызывает функцию. Дополнительные сведения см. в разделах Вызов функций Lambda и Использование AWS Lambda с другими сервисами.

Событие

Событие — это документ в формате JSON, содержащий данные для обработки функцией Lambda.
Среда выполнения преобразует событие в объект и передает его коду вашей функции. Когда вы вызываете функцию, вы
определить структуру и содержание мероприятия.

Пример пользовательского события — данные о погоде

 {
  «Температура К»: 281,
  "ВетерКмч": -3,
  "ВлажностьPct": 0,55,
  "ДавлениеHPa": 1020
} 

Когда служба AWS вызывает вашу функцию, служба определяет форму события.

Пример сервисного события — уведомление Amazon SNS

 {
  "Записи": [
    {
      "Снс": {
        «Временная метка»: «2019-01-02T12:45:07.000Z»,
        "Подпись": "tcc6faL2yUC6dgZdmrwh2Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
        "MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
        "Сообщение": "Привет из соцсетей!",
        ... 

Дополнительные сведения о событиях из сервисов AWS см. в разделе Использование AWS Lambda с другими сервисами.

Среда выполнения

Среда выполнения обеспечивает безопасную и изолированную среду выполнения для вашего
Лямбда-функция. Среда выполнения управляет процессами и ресурсами, необходимыми для запуска
функция. Среда выполнения обеспечивает поддержку жизненного цикла функции и любых расширений, связанных с вашей функцией.

Дополнительные сведения см. в разделе Среда выполнения Lambda.

Архитектура набора инструкций

Архитектура набора инструкций определяет тип компьютерного процессора, который Lambda
использует для запуска функции. Lambda предоставляет выбор архитектуры набора команд:

• arm64 — 64-битная архитектура ARM для процессора AWS Graviton2.

• x86_64 — 64-битная архитектура x86 для процессоров на базе x86.

Дополнительные сведения см. в разделе Архитектуры набора инструкций Lambda.

Пакет развертывания

Код функции Lambda развертывается с помощью пакет развертывания . лямбда
поддерживает два типа пакетов развертывания:

• Файловый архив .zip, содержащий код вашей функции и его зависимости. Lambda обеспечивает операционную
  система и среда выполнения для вашей функции.

• Образ контейнера, совместимый с Open Container
  Спецификация инициативы (OCI). Вы добавляете свой код функции и зависимости к образу. Вы должны
  также включает операционную систему и среду выполнения Lambda.

Дополнительные сведения см. в разделе Пакеты развертывания Lambda.

Среда выполнения

Среда выполнения предоставляет специфичную для языка среду, которая запускается при выполнении
Окружающая среда. Среда выполнения передает события вызова, контекстную информацию и ответы между Lambda и
функция. Вы можете использовать среды выполнения, предоставляемые Lambda, или создавать свои собственные. Если вы упаковываете свой код в виде файла .zip
архив, вы должны настроить свою функцию для использования среды выполнения, соответствующей вашему языку программирования. Для контейнера
образ, вы включаете среду выполнения при создании образа.

Дополнительные сведения см. в разделе Среды выполнения Lambda.

Слой

Слой Lambda — это файловый архив .zip, который может содержать дополнительный код или другое содержимое. А
слой может содержать библиотеки, пользовательскую среду выполнения, данные или конфигурацию
файлы.

Слои предоставляют удобный способ упаковки библиотек и других зависимостей, которые вы можете использовать с вашим Lambda
функции. Использование слоев уменьшает размер загружаемых архивов развертывания и ускоряет развертывание кода.
Слои также способствуют совместному использованию кода и разделению ответственности, чтобы вы могли быстрее выполнять итерации при написании.
бизнес-логика.

Вы можете включить до пяти слоев для каждой функции. Уровни учитываются в стандартных квотах на размер развертывания Lambda.
Когда вы включаете слой в функцию, содержимое извлекается в папку /opt .
каталог в среде выполнения.

По умолчанию создаваемые вами слои являются частными для вашей учетной записи AWS. Вы можете поделиться слоем с
другие учетные записи или сделать слой общедоступным. Если ваши функции используют слой, опубликованный другой учетной записью,
ваши функции могут продолжать использовать версию слоя после ее удаления или после вашего разрешения на доступ
слой аннулируется. Однако вы не можете создать новую функцию или обновить функции, используя удаленный слой.
версия.

Функции, развернутые как образ контейнера, не используют слои. Вместо этого вы упаковываете предпочитаемую среду выполнения,
библиотеки и другие зависимости в образ контейнера при сборке образа.

Дополнительные сведения см. в разделе Создание и совместное использование слоев Lambda.

Расширение

Расширения Lambda позволяют расширить ваши функции. Например, вы можете использовать
расширения для интеграции ваших функций с предпочитаемыми функциями мониторинга, наблюдения, безопасности и управления
инструменты. Вы можете выбирать из широкого набора инструментов, которые AWS Lambda
Партнеры предоставляют, или вы можете создать свою собственную Lambda
расширения.

Внутреннее расширение запускается в процессе выполнения и имеет тот же жизненный цикл, что и среда выполнения. Внешний
расширение запускается как отдельный процесс в среде выполнения. Внешнее расширение инициализируется до
функция вызывается, выполняется параллельно со средой выполнения функции и продолжает выполняться после функции
вызов завершен.

Дополнительные сведения см. в разделе Расширения Lambda.

Параллельность

Параллельность — это количество запросов, которые ваша функция обслуживает в любой момент времени.
Когда ваша функция вызывается, Lambda предоставляет ее экземпляр для обработки события. Когда код функции
закончит работу, он может обработать другой запрос. Если функция вызывается снова во время выполнения запроса
обрабатывается, создается еще один экземпляр, что увеличивает параллелизм функции.

Параллелизм регулируется квотами на уровне региона AWS. Ты
можно настроить отдельные функции, чтобы ограничить их параллелизм или позволить им достичь определенного уровня
параллелизм. Дополнительные сведения см. в разделе Настройка зарезервированного параллелизма.

Квалификатор

Когда вы вызываете или просматриваете функцию, вы можете включить квалификатор , чтобы указать версию или
псевдоним. Версия — это неизменяемый снимок кода и конфигурации функции, который имеет
числовой определитель.