Group items tagged

Serverless can also mean applications where some amount of server-side logic is still written by the application developer but unlike traditional architectures is run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a 3rd party.

‘Functions as a service

AWS Lambda is one of the most popular implementations of FaaS at present,

A good example is Auth0 - they started initially with BaaS ‘Authentication as a Service’, but with Auth0 Webtask they are entering the FaaS space.

a typical ecommerce app

a backend data-processing service

with zero administration.

FaaS offerings do not require coding to a specific framework or library.

Horizontal scaling is completely automatic, elastic, and managed by the provider

Functions in FaaS are triggered by event types defined by the provider.

from a deployment-unit point of view FaaS functions are stateless.

allowed the client direct access to a subset of our database

deleted the authentication logic in the original application and have replaced it with a third party BaaS service

The client is in fact well on its way to becoming a Single Page Application.

implement a FaaS function that responds to http requests via an API Gateway

port the search code from the Pet Store server to the Pet Store Search function

replaced a long lived consumer application with a FaaS function that runs within the event driven context

server applications - is a key difference when comparing with other modern architectural trends like containers and PaaS

the only code that needs to change when moving to FaaS is the ‘main method / startup’ code, in that it is deleted, and likely the specific code that is the top-level message handler (the ‘message listener interface’ implementation), but this might only be a change in method signature

With FaaS you need to write the function ahead of time to assume parallelism

Most providers also allow functions to be triggered as a response to inbound http requests, typically in some kind of API gateway

you should assume that for any given invocation of a function none of the in-process or host state that you create will be available to any subsequent invocation.

FaaS functions are either naturally stateless

certain classes of long lived task are not suited to FaaS functions without re-architecture

if you were writing a low-latency trading application you probably wouldn’t want to use FaaS systems at this time

An API Gateway is an HTTP server where routes / endpoints are defined in configuration and each route is associated with a FaaS function.

API Gateway will allow mapping from http request parameters to inputs arguments for the FaaS function

API Gateways may also perform authentication, input validation, response code mapping, etc.

the Serverless Framework makes working with API Gateway + Lambda significantly easier than using the first principles provided by AWS.

Apex - a project to ‘Build, deploy, and manage AWS Lambda functions with ease.'

'Serverless' to mean the union of a couple of other ideas - 'Backend as a Service' and 'Functions as a Service'.

config/environments/production.rb

Create an additional staging environment that closely resembles the production one

Keep any additional configuration in YAML files under the config/ directory

Rails::Application.config_for(:yaml_file)

Use nested routes to express better the relationship between ActiveRecord models

nest routes more than 1 level deep then use the shallow: true option

namespaced routes to group related actions

Keep the controllers skinny

all the business logic should naturally reside in the model

Share no more than two instance variables between a controller and a view.

using a template

Prefer corresponding symbols to numeric HTTP status codes

without abbreviations

Keep your models for business logic and data-persistence only

Avoid altering ActiveRecord defaults (table names, primary key, etc)

Prefer has_many :through to has_and_belongs_to_many

self[:attribute]

self[:attribute] = value

validates

Consider extracting custom validators to a shared gem

preferable to make a class method instead which serves the same purpose of the named scope

.update_attributes

Override the to_param method of the model

Use the friendly_id gem. It allows creation of human-readable URLs by using some descriptive attribute of the model instead of its id

.find_each

.find_each

Looping through a collection of records from the database (using the all method, for example) is very inefficient since it will try to instantiate all the objects at once

always call before_destroy callbacks that perform validation with prepend: true

When persisting AR objects

Avoid string interpolation in queries

param will be properly escaped

Consider using named placeholders instead of positional placeholders

use of find over where when you need to retrieve a single record by id

use of find_by over where and find_by_attribute

use of where.not over SQL

use heredocs with squish

Use rake db:schema:load instead of rake db:migrate to initialize an empty database

change_column_default

imposing data integrity from the Rails app is impossible

use the change method instead of up and down methods.

constructive migrations

use models in migrations, make sure you define them so that you don't end up with broken migrations in the future

In this case, block will be used by create_table in rollback

Never make complex formatting in the views, export the formatting to a method in the view helper or the model.

When the labels of an ActiveRecord model need to be translated, use the activerecord scope

Separate the texts used in the views from translations of ActiveRecord attributes

config/application.rb config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}')]

I18n.t

I18n.l

Use "lazy" lookup for the texts used in views.

Use the dot-separated keys in the controllers and models

Reserve app/assets for custom stylesheets, javascripts, or images

Third party code such as jQuery or bootstrap should be placed in vendor/assets

Provide both HTML and plain-text view templates

config.action_mailer.raise_delivery_errors = true

Use a local SMTP server like Mailcatcher in the development environment

Provide default settings for the host name

The _url methods include the host name and the _path methods don't

Format the from and to addresses properly

default from:

sending html emails all styles should be inline

Sending emails while generating page response should be avoided. It causes delays in loading of the page and request can timeout if multiple email are sent.

.start_with?

.end_with?

&.

Config your timezone accordingly in application.rb

config.active_record.default_timezone = :local

it can be only :utc or :local

Time.zone.parse

Time.zone.now