Слияние кода завершено, страница обновится автоматически
Serverless Components теперь доступны для общего использования. Нажмите здесь, чтобы перейти к старой бета-версии.
Серверные компоненты — это простые абстракции, которые позволяют разработчикам легко развёртывать бессерверные приложения и сценарии использования с помощью Serverless Framework.
Преимущества:
Быстрое развёртывание бессерверного приложения с любой из этих команд:
$ npx serverless init fullstack-app
$ npx serverless init express-starter
$ npx serverless init react-starter
$ npx serverless init vue-starter
$ npx serverless init graphql-starter
— Быстрый старт; — Обзор; — Использование компонентов; — Серверная структура; — serverless.yml; — Действия, входные данные и выходные данные; — Развёртывание; — Состояние; — Учётные данные; — Этапы; — Переменные; — Прокси; — Команды CLI; — Создание компонентов; — Список компонентов (https://github.com/serverless-components); — Часто задаваемые вопросы.
Чтобы начать работу с Serverless Components, установите последнюю версию Serverless Framework:
$ npm i -g serverless
После установки запустите serverless registry, чтобы увидеть множество шаблонов на основе компонентов, которые вы можете развернуть, или узнайте больше на панели инструментов Serverless Framework (https://app.serverless.com). Они содержат компоненты, а также шаблонный код, который поможет вам быстро приступить к работе. Установка из реестра с помощью команды $ serverless init <template>:
$ serverless init express-starter
Перейдите в созданный каталог.
Наконец, введите учётные данные облачного провайдера в файл .env в папке, содержащей ваш serverless.yml, или в её непосредственной родительской папке.
AWS_ACCESS_KEY_ID=12345
AWS_SECRET_ACCESS_KEY=5321
И разверните!
$ serverless deploy
Через несколько секунд вы должны получить URL в качестве вывода. Если вы посетите этот URL, вы увидите успешное сообщение «Запрос получен».
Получите информацию о вашем экземпляре компонента...
$ serverless info
Запустите команду serverless dev, чтобы автоматически развёртывать при сохранении и получать журналы и ошибки в реальном времени на вашей консоли (если поддерживается компонентом)...
$ serverless dev
Разверните другие компоненты, которые вы можете захотеть использовать с вашим компонентом Express. Например, вы можете предоставить своему приложению Express разрешения для других ресурсов в своей учётной записи AWS через компонент aws-iam-role. Вы также можете использовать таблицу AWS DynamoDB с вашим приложением Express через компонент aws-dynamodb. Вы можете инициализировать и развернуть их так же, как компонент express. Затем вы можете использовать их со своим компонентом express, например:
org: your-org # Your Org
app: your-app # Your App
component: express
name: express-api
inputs:
src: ./src
roleName: ${output:my-role.name}
env:
dbTableName: ${output:${stage}:${app}:my-table.name}
Обратите внимание: в настоящее время Serverless Components поддерживает только приложения Node.js.
Serverless Components — это библиотеки кода, которые упрощают развёртывание приложений и другой функциональности в бессерверную облачную инфраструктуру. Это готовые бессерверные варианты использования, содержащие лучшие шаблоны инфраструктуры для масштабирования, производительности, оптимизации затрат, совместной работы и многого другого.
Мы (Serverless Inc) создали Serverless Components, потому что составление, настройка и управление низкоуровневой бессерверной инфраструктурой могут быть сложными для разработчиков и команд. Мы обнаружили множество лучших шаблонов и теперь хотим поделиться ими!
Хотя компоненты могут помочь вам развернуть и управлять низкоуровневой инфраструктурой (например, корзиной AWS S3), их основное применение — более высокоуровневые функции и приложения, такие как:
Серверные компоненты построены вокруг высокоуровневых вариантов использования (например, веб-сайт, блог, платёжная система). Ненужные детали инфраструктуры низкого уровня (которые не нужны для варианта использования) абстрагируются, и вместо этого предлагается более простая конфигурация.
Например, вот как выглядит предоставление бессерверного веб-сайта, размещённого на AWS S3, доставляемого глобально и быстро с помощью AWS Cloudfront, через пользовательский домен на AWS Route 53, защищённого бесплатным SSL-сертификатом AWS ACM:
# serverless.yml
org: acme # Your Org
app: ecommerce # Your App
component: website # A Component in the Registry
name: my-website # The name of your Component Instance
inputs: # The configuration the Component accepts
src:
src: ./src
hook: npm run build
dist: ./dist
env:
# environment variables to pass to the website build environment
REACT_APP_API_URL: https://api.example.com
domain: mystore.com
Бессерверные компоненты развёртываются мгновенно, устраняя необходимость эмулировать облачные сервисы локально для быстрой обратной связи во время разработки.
$ serverless deploy
4s > my-express-app › Successfully deployed
Бессерверные компоненты легко пишутся на JavaScript (serverless.js), с простым синтаксисом, вдохновлённым компонентно-ориентированными фреймворками, такими как React.
// serverless.js
const { Component } = require('@serverless/core');
class MyBlog extends Component {
async deploy(inputs) { **Развертывание**
Компоненты можно легко развернуть через Serverless Framework с помощью команды `$ serverless deploy`.
```bash
$ serverless deploy
Эту команду можно запустить в любом каталоге, содержащем допустимый файл компонентов serverless.yml, как показано выше. Вы также можете запустить $ serverless deploy в любом каталоге, который содержит несколько каталогов компонентов, и в этом случае он будет развертывать все эти компоненты параллельно, когда это возможно, в соответствии с зависимостями их выходных переменных. Если вы хотите убедиться, что все эти связанные компоненты развертываются в одной организации, приложении и этапе, вы можете создать файл serverless.yml на родительском уровне, который включает эти свойства. Шаблон fullstack-app (https://github.com/serverless-components/fullstack-app) является хорошим примером для всего этого.
Хотя Serverless Components развертываются невероятно быстро, обратите внимание, что первые развертывания часто могут быть в 2 раза медленнее, потому что создание облачных ресурсов занимает гораздо больше времени, чем их обновление. Также обратите внимание, что некоторым ресурсам требуется несколько минут, чтобы стать доступными. Например, API и URL веб-сайта могут занять 1–2 минуты, прежде чем они станут доступны.
Состояние
Serverless Components автоматически сохраняют свое состояние удаленно. Это означает, что вы можете легко отправить свои Компоненты в Github, Gitlab, Bitbucket и т. д. и сотрудничать с другими, пока serverless.yml содержит org, к которой добавлены ваши коллеги:
org: acme-team # Ваши коллеги должны быть добавлены на dashboard.serverless.com
app: ecommerce
component: my-component
name: rest-api
Кроме того, ваши экземпляры компонентов можно легко развернуть с CI/CD, если вы убедитесь, что включили переменную среды SERVERLESS_ACCESS_KEY.
Вы можете добавлять коллег и создавать токены доступа в Dashboard Serverless Framework.
Версии
В Serverless Components используется семантическое управление версиями.
component: express@0.0.2
Когда вы добавляете версию, используется только эта версия компонента. Когда вы не добавляете версию, Serverless Framework будет использовать последнюю версию этого компонента, если она существует. Мы рекомендуем всегда привязывать ваш компонент к версии.
Учетные данные
После развертывания Serverless Framework ищет файл .env в текущем рабочем каталоге, а также в непосредственном родительском каталоге. Компоненты могут найти эти учетные данные в объекте this.credentials. Однако вы должны использовать следующие ключи переменных среды:
AWS_ACCESS_KEY_ID=123456789
AWS_SECRET_ACCESS_KEY=123456789
Компоненты могут получить доступ к этим учетным данным AWS с помощью this.credentials.aws. Этот объект будет выглядеть следующим образом:
{
accessKeyId: '123456789',
secretAccessKey: '123456789',
}
Примечание: Для AWS, если файл .env не был найден в текущем рабочем или родительском каталогах, CLI попытается получить учетные данные из общего файла учетных данных AWS (обычно расположенного по адресу ~/.aws/credentials) в качестве запасного варианта в соответствии с вашими переменными среды AWS_DEFAULT_PROFILE или AWS_PROFILE, точно так же, как это работает в AWS SDK.
AWS_PROFILE=myprofile
CLI проверит общий файл учетных данных AWS (как правило, расположенный по адресу ~/.aws/credentials) на наличие конфигурации «role_arn» и «source_profile» для предоставленного профиля и примет эту роль с использованием API AWS STS. Общий файл учетных данных AWS должен выглядеть следующим образом: Компоненты Serverless имеют концепцию Stages, которая позволяет развёртывать полностью отдельные экземпляры компонентов и их облачные ресурсы для каждого этапа.
Этап dev всегда используется по умолчанию. Если вы хотите изменить свой этап, установите его в файле serverless.yml, например:
org: my-org
app: my-app
component: express@0.0.2
name: my-component-instance
stage: prod # Введите здесь этап
Вы также можете указать этап в переменной среды SERVERLESS_STAGE, которая переопределяет значение stage, установленное в serverless.yml:
SERVERLESS_STAGE=prod
И вы можете указать этап при развёртывании через флаг CLI, который переопределяет всё, что установлено в serverless.yml И переменную среды, например:
$ serverless deploy --stage prod
Опять же, флаг CLI переопределяет как значение stage в serverless.yml, так и переменную среды. В то время как переменная среды может только переопределить значение stage в serverless.yml.
Наконец, вы можете установить переменные среды для конкретного этапа, используя отдельные файлы .env. Каждый файл должен быть назван в следующем формате: .env.STAGE. Например, если вы работаете на этапе prod, будут загружены переменные среды из файла .env.prod, в противном случае будет загружен файл по умолчанию .env (без расширения этапа). Вы также можете поместить файл .env.STAGE в родительский каталог, если у вас есть родительская папка, содержащая множество экземпляров компонентов.
Практическое использование этого заключается в том, что если вы хотите иметь отдельную учётную запись AWS для каждого этапа, вы будете хранить отдельные учётные данные AWS для каждого целевого этапа. Затем, в зависимости от этапа, на который вы развёртываете, будут выбраны правильные учётные данные.
Вы можете использовать переменные в своих экземплярах компонентов serverless.yml для ссылки на переменные среды, значения из serverless.yml и выходные данные других уже развёрнутых экземпляров бессерверных компонентов.
Вот краткий обзор возможностей:
org: acme
app: ecommerce
component: express
name: rest-api
stage: prod
inputs:
name: ${org}-${stage}-${app}-${name} # Результаты в "acme-prod-ecommerce-rest-api"
region: ${env:REGION} # Результаты соответствуют тому, что задано в вашей переменной окружения REGION=
roleArn: ${output:prod:my-app:role.arn} # Получает вывод от другого экземпляра компонента, который уже развёрнут
roleArn: ${output:${stage}:${app}:role.arn} # Вы также можете комбинировать переменные
``` **in serverless.yml с помощью переменной ${org}:**
```yml
org: acme
app: ecommerce
component: express
name: rest-api
stage: prod
inputs:
name: ${org}-api # Результаты в "acme-api"
Примечание: Если вы не указали org, то по умолчанию будет использоваться первая организация, которую вы создали при регистрации. Вы всегда можете перезаписать значение по умолчанию или указанное в serverless.yml, передав параметр --org при развёртывании:
$ serverless deploy --org my-other-org
Вы можете ссылаться на значение stage в inputs вашего YAML в serverless.yml с помощью переменной ${stage}:
org: acme
app: ecommerce
component: express
name: rest-api
stage: prod
inputs:
name: ${stage}-api # Результаты в «prod-api»
Примечание: Если вы не укажете stage, по умолчанию будет использоваться dev. Вы всегда можете перезаписать значение по умолчанию или указанное в serverless.yml, передав параметр --stage при развёртывании:
$ serverless deploy --stage prod
Вы можете сослаться на значение app в inputs вашего YAML в serverless.yml с помощью переменной ${app}:
org: acme
app: ecommerce
component: express
name: rest-api
stage: prod
inputs:
name: ${app}-api # Результаты в «ecommerce-api»
Примечание: если вы не укажете app, по умолчанию будет использовано имя экземпляра (свойство name в serverless.yml). Вы всегда можете перезаписать значение по умолчанию или указанное в serverless.yml, передав параметр --app при развёртывании:
$ serverless deploy --app my-other-app
Вы можете сослаться на значение name в inputs вашего YAML в serverless.yml с помощью переменной ${name}:
org: acme
app: ecommerce
component: express
name: rest-api
stage: prod
inputs:
name: ${name} # Результаты в «rest-api»
Можно ссылаться на переменные среды (например, те, которые вы определили в файле .env или установили в своей среде вручную) непосредственно в serverless.yml с использованием переменной ${env}.
Например, если вы хотите сослаться на переменную среды REGION, вы можете сделать это с помощью ${env:REGION}.
component: express
org: acme
app: ecommerce
name: rest-api
stage: prod
inputs:
region: ${env:REGION}
Возможно, одна из самых полезных переменных — это возможность ссылаться на Outputs из других уже развёрнутых экземпляров компонентов. Это позволяет легко обмениваться конфигурацией/данными между любым количеством экземпляров компонентов.
Если вы хотите сослаться на вывод другого экземпляра компонента, используйте синтаксис ${output:[app]:[stage]:[instance name].[output]}:
component: express
org: acme
app: ecommerce
name: rest-api
stage: prod
inputs:
roleArn: ${output:[STAGE]:[APP]:[INSTANCE].arn} # Получает вывод из другого уже развёрнутого экземпляра компонента
Вы можете получить доступ к Outputs через любое приложение, экземпляр, в любой стадии, в пределах одной организации.
Полезной особенностью этого является возможность легко делиться ресурсами и даже делать это между средами. Это полезно, когда разработчики хотят развернуть экземпляр компонента в своём личном этапе, но получить доступ к общим ресурсам в общем этапе разработки, например, к базе данных. Таким образом, разработчикам в вашей команде не нужно воссоздавать весь этап разработки для выполнения своей работы над функциями или исправлениями ошибок, а только экземпляр компонента, который нуждается в изменениях.
Проблема: ваша среда не имеет разрешения на доступ к общедоступной сети и может получить доступ к ней только через прокси, и при выполнении команды sls deploy сообщается о сбое сети.
Решение: добавьте следующую конфигурацию в файл .env, требуется версия Node.js >= 11.7.0:
HTTP_PROXY=http://127.0.0.1:12345 # Ваш прокси
HTTPS_PROXY=http://127.0.0.1:12345 # Ваш прокси **Опубликовать компонент в бессерверном реестре**
`--dev` — публикует версию компонента `@dev`, предназначенную для тестирования.
#### `serverless init <package-name>`
Инициализирует указанный пакет (компонент или шаблон) локально, чтобы быстро приступить к работе.
`–dir`, `-d` — указать целевой каталог.
#### `serverless deploy`
Развертывает экземпляр компонента.
`—debug` — выводит операторы `console.log()`, оставленные в компоненте после `deploy` или любого действия.
#### `serverless remove`
Удаляет экземпляр компонента.
`—debug` — выводит операторы `console.log()`, оставшиеся в компоненте при `remove` или любом действии.
#### `serverless info`
Получает информацию об экземпляре компонента.
`—debug` — отображает `state`.
#### `serverless dev`
Запускает режим DEV, который отслеживает изменения компонента, автоматически развертывает их и (если поддерживается компонентом) передает журналы, ошибки и транзакции на терминал.
#### `serverless param` — **доступно только для китайских пользователей**
Пользователь может устанавливать и перечислять значения секретов в качестве параметров с помощью CLI с приложением и этапом.
##### Установка параметров
`serverless param set id=param age=12 [–app test] [–stage dev]`
— пользователь может установить несколько параметров одновременно, используя `paramName=paramValue`;
— если пользователь не устанавливает приложение или этап, CLI будет читать из файла конфигурации или использовать значения по умолчанию.
###### Список параметров
`serverless param list [–app test] [–stage dev]`
— если пользователь не задает приложение или стадию, CLI будет считывать из файла конфигурации или использовать значения по умолчанию;
— CLI покажет все параметры для текущей стадии и приложения.
##### Использование параметров в serverless.yml
#### `serverless <command> —inputs key=value foo=bar`
Выполняет любую пользовательскую команду компонента и передает ей входные данные. Входные данные, переданные в указанном выше синтаксисе, перезаписывают любые входные данные, найденные в файле `serverless.yml`.
Несколько примеров:
serverless test —inputs domain=serverless.com
serverless invoke —inputs env='{"LANG": "en"}'
serverless backup —inputs userIds=foo,bar
<br/>
**Создание компонентов**
Если вы хотите создать собственный бессерверный компонент, вам необходимо знать о двух важных файлах:
* `serverless.component.yml` — содержит определение вашего бессерверного компонента;
* `serverless.js` — содержит код вашего бессерверного компонента.
Одна из самых важных вещей, которую следует отметить, это то, что бессерверные компоненты **работают только** в облаке и **не работают** локально. Это означает, что для запуска и тестирования компонента его необходимо сначала опубликовать (это занимает всего несколько секунд). Мы продолжаем улучшать этот рабочий процесс. Вот как это сделать...
### `serverless.component.yml`
Чтобы объявить бессерверный компонент и сделать его доступным в бессерверном реестре, необходимо создать файл `serverless.component.yml` со следующими свойствами:
```yaml
# serverless.component.yml
name: express # Обязательное. Имя Компонента
version: 0.0.4 # Обязательное. Версия Компонента
author: eahefnawy # Обязательное. Автор Компонента
org: serverlessinc # Обязательное. Бессерверная организация Framework, которой принадлежит этот компонент
main: ./src # Обязательный. Каталог, содержащий код Компонента
description: Развертывает бессерверные приложения Express.js # Необязательный. Описание Компонента
keywords: aws, serverless, express # Необязательные. Ключевые слова Компонента, чтобы его было легче найти на registry.serverless.com
repo: https://github.com/owner/project # Необязательный. Репозиторий кода Компонента
license: MIT # Необязательная. Лицензия кода Компонента
serverless.js
Файл serverless.js содержит код бессерверного Компонента.
Чтобы создать минимальный бессерверный Компонент, создайте файл serverless.js, расширьте класс Компонента и добавьте метод deploy, как показано ниже:
// serverless.js
const { Component } = require('@serverless/core');
class MyComponent extends Component {
async deploy(inputs = {}) {
return {};
} // Если вы используете тип `metrics` в вашем компоненте,
то он будет представлять собой массив поддерживаемых виджетов метрик, которые можно динамически отображать в графических пользовательских интерфейсах. **Когда всё готово, вы можете использовать этот служебный метод, чтобы снова заархивировать исходные файлы**, потому что в некоторых случаях вам нужно будет загрузить код на вычислительный сервис (например, AWS Lambda).
```javascript
async deploy(inputs = {}) {
// Заархивируем исходные файлы...
const zipPath = await this.zip(sourceDirectory)
}
Если ваш компонент запускает код и вы хотите включить потоковую передачу журналов, ошибок и транзакций для вашего компонента через бессерверный режим разработки (serverless dev), обязательно добавьте бессерверный SDK в развёрнутое приложение/логику. Мы предлагаем несколько полезных служебных методов, которые делают это возможным:
// Распаковываем исходный zip-файл
console.log(`Распаковка ${inputs.src}...`);
const sourceDirectory = await instance.unzip(inputs.src);
console.log(`Файлы распакованы в ${sourceDirectory}...`);
// Добавляем SDK в исходный каталог, добавляем оригинальный обработчик
console.log(`Установка бессерверного фреймворка SDK...`);
instance.state.handler = await instance.addSDK(sourceDirectory, '_express/handler.handler');
// Архивируем исходный каталог с прокладкой и SDK
console.log(`Архивация файлов...`);
const zipPath = await instance.zip(sourceDirectory);
console.log(`Файлы заархивированы в ${zipPath}...`)
После этого вы, скорее всего, захотите загрузить код на вычислительную службу (например, AWS Lambda).
Бессерверные компоненты запускаются только в облаке и не могут быть запущены локально. Это даёт некоторые огромные преимущества потребителям компонентов, и мы добавили несколько приёмов рабочего процесса, чтобы упростить процесс создания. Вот они...
Когда вы добавили или обновили код своего бессерверного компонента и хотите протестировать изменение, вам сначала нужно опубликовать его. Поскольку вы не хотите публиковать свои изменения в правильной версии вашего компонента только для тестирования (потому что люди могут его использовать), мы позволяем вам опубликовать «dev»-версию вашего компонента.
Просто выполните следующую команду, чтобы опубликовать свой бессерверный компонент в «dev»-версии:
$ serverless publish --dev
Вы можете протестировать «dev»-версию своего компонента в serverless.yml, включив @dev в имя вашего компонента, например так:
# serverless.yml
org: acme
app: fullstack
component: express@dev # Добавляем «dev» как версию
name: rest-api
inputs:
src: ./src
Запустите команду компонента, чтобы протестировать изменения:
$ serverless deploy --debug
При написании компонента мы рекомендуем всегда использовать флаг --debug, чтобы операторы console.log() компонента отправлялись в CLI. Они полезны для использования в бессерверных компонентах, поскольку описывают, что делает компонент. Мы рекомендуем вам добавлять операторы console.log(), где вы считаете это необходимым.
class MyComponent extends Component {
async deploy(inputs) {
console.log(`Запуск MyComponent.`);
console.log(`Создание ресурсов.`);
console.log(`Ожидание подготовки ресурсов.`);
console.log(`Завершение MyComponent.`);
return {};
}
}
Когда вы будете готовы опубликовать новую версию для других пользователей, обновите версию в serverless.component.yml и запустите публикацию без флага --dev.
# serverless.component.yml
name: express@0.0.1
$ serverless publish
Serverless: Успешно опубликовать express@0.0.1
Вот несколько советов по разработке при написании бессерверных компонентов:
Мы рекомендуем начать с фокусировки на желаемом результате, а не пытаться разбить вещи на несколько более мелких компонентов с самого начала. Попытка разбить вещи на несколько компонентов чаще всего отвлекает. Сначала создайте компонент более высокого уровня, который решает вашу проблему. Используйте его. Учитесь на нём. Затем рассмотрите возможность разбиения вещей на более мелкие компоненты, если это необходимо. В то же время решения высокого уровня — это то, для чего предназначены бессерверные компоненты. Они являются результатами с наименьшими операционными издержками.
Provisioning Компоненты работают в облаке. Вот что это значит и почему это важно...
Мы работаем над Serverless Framework уже 5 лет. За это время мы хотели улучшить решение проблем пользователей, повысить качество работы и внедрить инновации, но нас ограничивал дизайн проекта (например, требуется локальная установка, сложно вносить обновления, отсутствует диагностика ошибок, приходится учитывать особенности среды пользователя и т. д.).
Более года назад мы обсудили несколько революционных способов расширить границы инструментов для разработки серверных приложений без выделения ресурсов (и инфраструктуры как кода в целом) и поняли, что единственный способ сделать это — перенести большую часть работы в облако.
Теперь при развёртывании или выполнении любого другого действия с компонентом это происходит в нашем «Механизме компонентов», который мы разрабатывали более полутора лет. Для ясности: ваш исходный код, переменные среды и учётные данные проходят через Механизм компонентов.
Это полностью меняет традиционный подход к работе Serverless Framework. Однако это не отличается от того, как работает большинство механизмов сборки, продуктов CI/CD и облачных сервисов, а также AWS CloudFormation, который традиционно использовался в Serverless Framework. Механизм компонентов — это управляемый сервис, такой как AWS CloudFormation, CircleCI, Github, Github Actions, Hosted Gitlab, Terraform Cloud и др.
На сегодняшний день Механизм компонентов позволил реализовать следующее:
Часть этих функций позволит обеспечить более высокий уровень безопасности, чем когда-либо в Serverless Framework. Функции, которые упростят сокращение объёма ваших учётных данных, анализ/блокировку всего, проходящего через Механизм, откат небезопасных развёртываний и т.д.
Вы можете оставить комментарий после Вход в систему
Неприемлемый контент может быть отображен здесь и не будет показан на странице. Вы можете проверить и изменить его с помощью соответствующей функции редактирования.
Если вы подтверждаете, что содержание не содержит непристойной лексики/перенаправления на рекламу/насилия/вульгарной порнографии/нарушений/пиратства/ложного/незначительного или незаконного контента, связанного с национальными законами и предписаниями, вы можете нажать «Отправить» для подачи апелляции, и мы обработаем ее как можно скорее.
Комментарии ( 0 )