DevOps.js

DevOps.js Conf 2024

The Talk covers the speaker's personal journey into server-side rendering (SSR) and the evolution of web development frameworks. It explores the use of jQuery for animations in SSR, the challenges faced in integrating React with Umbraco, and the creation of a custom SSR framework. The Talk also discusses the benefits of Next.js and the use of serverless artifacts for deployment. Finally, it highlights the features of Astro, including its function per route capability.

A walk-through of the evolution of SSR in the last twelve years. We will cover how techniques changed, typical problems, tools you can use and various solutions, all from the point of view of my personal experience as a consumer and maintainer.

You Don’t Know How to SSR

Emanuele Stoppa

The workshop explores the intersection of serverless and AI, discussing the basics, benefits, scalability, and challenges of serverless. It also delves into AI architecture components, vector databases, and the use of context in querying. The workshop demonstrates the building process using HonoJS and Linkchain, setting up Cloudflare Workers and Wrangler, and loading data into a vector database. It also covers the creation of a chatbot with Cloudflare Workers AI and the use of API tokens and environment variables. The workshop concludes with information on pricing and recommendations for further questions.

In this workshop, we discuss the merits of serverless architecture and how it can be applied to the AI space. We'll explore options around building serverless RAG applications for a more lambda-esque approach to AI. Next, we'll get hands on and build a sample CRUD app that allows you to store information and query it using an LLM with Workers AI, Vectorize, D1, and Cloudflare Workers.

AI on Demand: Serverless AI

Nathan Disidore

This Talk provides an introduction to Serverless Observability and SLOs, explaining the concept of SLOs and their dependency on transforms. It highlights the codependency between SLOs, SLAs, and SLIs and discusses the importance of well-defined SLOs. The Talk also demonstrates how to create and monitor SLOs and alert rules, emphasizing the benefits of burn rate alerting in reducing alert fatigue and improving user experience.

This talk explores the use case of SLOs and transforms whilst migration to the serverless ecosystem. The talk starts by presenting the reasons why SLOs are important in the SRE/DevOps framework. It then analyses specific use cases of SLOs, the tools used for measuring the efficiency of SLOs and presents the main bottlenecks encountered when defining and adhering to SLOs in the process of migrating to a serverless ecosystem, especially when dealing with burn rates and transforms.By the end of the talk, the audience will be able to subscribe to the following takeaways:SLOs are important in a SRE/DevOps framework and there are numerous advantages for implementing them as long as they adhere to a process of continuous improvement.Adopting the right tools and metrics are paramount in the implementation of SLOs.Migrating to serverless adds pressure to the observability system and it is possible that burn rates and transforms will backfire. Our use case will show how it's possible to mitigate these challenges and learn from similar situations.

Serverless Observability: Where SLOs Meet Transforms

Virginia Diana Todea

React Summit

React Summit 2023

GraphQL is a strongly typed, version-free query language that allows you to ask for specific data and get it in JSON format. It simplifies data retrieval and modification by allowing the server to handle all necessary operations. Serverless architectures, such as AWS Lambda, are scalable, cost-effective, and good for event-driven applications. Event sourcing and CQRS are techniques that ensure consistency and separate reading and writing parts of an application. Building a GraphQL API with commands and queries can be achieved using AWS AppSync and DynamoDB. This approach offers low latency, scalability, and supports multiple languages. Challenges include application complexity, data modeling, and tracing, but starting with simplicity and making something work first can lead to success.

GraphQL is a powerful and useful tool, especially popular among frontend developers. It can significantly speed up app development and improve application speed, API discoverability, and documentation. GraphQL is not an excellent fit for simple APIs only - it can power more advanced architectures. The separation between queries and mutations makes GraphQL perfect for event sourcing and Command Query Responsibility Segregation (CQRS). By making your advanced GraphQL app serverless, you get a fully managed, cheap, and extremely powerful architecture.

Advanced GraphQL Architectures: Serverless Event Sourcing and CQRS

Slobodan Stojanović

Node Congress

Node Congress 2023

In this Talk, key characteristics of AWS Lambda functions are covered, including service architecture, composition, and optimization of Node.js code. The two operational models of Lambda, asynchronous and synchronous invocation, are explained, highlighting the scalability and availability of the service. The features of Lambda functions, such as retries and event source mapping, are discussed, along with the micro VM lifecycle and the three stages of a Lambda function. Code optimization techniques, including reducing bundle size and using caching options, are explained, and tools like webpack and Lambda Power Tuning are recommended for optimization. Overall, Lambda is a powerful service for handling scalability and traffic spikes while enabling developers to focus on business logic.

In this talk I explain how the AWS Lambda service works explaining the architecture, how it scales and how a developer should think about when they design their software using Lambda functions

AWS Lambda under the hood

Luca Mezzalira

Implementing the right strategies and tools, such as Apache Lucene, can improve search performance and user experience. The choice of analyzer affects search results, and query operators provide various search options. Relevant scoring is crucial for ranking documents based on relevance. Custom scoring can prioritize specific criteria. Consider analyzers, query operators, and scoring methods to optimize the search experience.

Building search into applications can be quite easy. This talk has been really fun for audiences because I often get audience members involved, often building out the code themselves, while they try to stump each other by naming the hardest things to find. The application is hosted in a Code Sandbox, so the audience takes the code home with them. Also, I can do the same presentation with movies, if the organizers prefer.

Game Changer! Building Search Into Your Applications

Karen Huaulme

The Talk discusses the challenges of IoT development, including issues with fleet offline, data missing, alerts not working, inconsistent data, and slow loading dashboards. It explores how to build observability in IoT applications using metrics, logging, and tracing. The integration between the rules engine and Lambda is explained, highlighting the use of tools like Lambda Power Tools and X-Ray for logging, monitoring, and tracing. The Lambda invocation process and the tracing capabilities of X-Ray are also mentioned.

Observability is crucial for successfully operating large IoT fleets. IoT incorporates different components, including hardware, network, on-device software, and cloud. Devices operate under unreliable conditions and constraints, and need to be monitored remotely. Cloud applications become complex and costly, as they are built to handle device activity at scale. Answering questions such as: -    Do I have a problem in my IoT application? -    Where is the problem? -    What is causing the problem? -    How much of my fleet is affected? -    Is my code expensive to run and if yes, how can I fix that? , can be challenging. Logging, monitoring and tracing are fundamental observability pillars. However, they are often viewed as non-functionals in IoT applications, and can fall off the radar, or are not standardized during development. This session will show how to leverage Open Source tools, such as AWS Lambda PowerTools, in a fully functional Serverless IoT application, to ease adoption of best practices for modern application development, and integrate services such as Amazon X-Ray, Amazon CloudWatch and AWS IoT Core features, to achieve end-to-end observability.

Tools for better Observability in NodeJS Serverless IoT Applications

Alina Dima

React Summit 2022

The Workshop focuses on building an open-source project using serverless technologies and React. It covers various topics such as choosing serverless approaches, debugging serverless code, working with databases, and creating a data model. The workshop also explores deploying React apps to a serverless setup, server-side rendering, and static site generation. It discusses the benefits of serverless, the use of Zada as a serverless database, and the concept of edge functions. Overall, the workshop provides a comprehensive overview of working with serverless and React for modern front-end development.

Intro to serverlessPrior Art: Docker, Containers, and KubernetesActivity: Build a Dockerized application and deploy it to a cloud providerAnalysis: What is good/bad about this approach?Why Serverless is Needed/BetterActivity: Build the same application with serverlessAnalysis: What is good/bad about this approach?

Serverless for React Developers

Tejas Kumar

DevOps.js Conf 2022

Welcome to my session on Serverless for Front-ends. Serverless functions eliminate the need for a runtime and handle orchestration for you. Microfrontends require a runtime and orchestration, but side-less UIs provide a runtime-free solution. In the demo, a new team adds functionality to an application and publishes it easily. Building and deploying applications is quick and easy with micro apps and PowerCLI, offering true loose coupling and instant availability without a runtime.

In this talk micro frontend expert Florian Rappl will introduce the pattern of creating a Siteless UI. This is a frontend composed of different pieces that can be developed independently and are deployed without having or managing any server. Florian will show you how to get started in that space, what decisions to take, and what pitfalls you should avoid. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Serverless for Frontends

Florian Rappl

Node Congress 2022

This Talk provides valuable insights for those considering serverless in 2022, with a focus on troubleshooting and observability using Lumigo. It emphasizes the use of multiple AWS accounts and Org Formation for better control and scalability. Security considerations include securely loading secrets at runtime and implementing zero-trust networking. Optimizing Lambda performance is discussed, along with updates on serverless frameworks and the role of Terraform. The Talk also compares Honeycomb and Lumigo for observability in serverless applications.

Serverless technologies help us build better and more scalable applications in the cloud. It's a powerful paradigm that allows us to focus on creating business values and letting the cloud provider handle the undifferentiated heavy-liftings such as managing the underlying infrastructure. In this session, Yan Cui would take us through many of the lessons that he has learnt from running serverless workloads in production over the last five years, including development tips, testing and observability strategies, and much more. You can check the slides for Yan's talk <a href="https://drive.google.com/file/d/1cHZIF9E82VxEAd6s_YZ_d-UexuRWWsrX/view?usp=sharing">here</a>. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Serverless in Production, Lessons from the Trenches

Yan Cui

Polyscale is a no-code database edge cache that aims to make caching and speeding up the data layer effortless for developers. It uses AI and machine learning to adjust caching behavior, selectively choosing what to cache and automatically setting cache duration. Polyscale supports multiple databases and provides detailed observability. It eliminates the need for caching at the application tier and offers significant performance gains.

This workshop discusses the challenges Enterprises are facing when scaling the data tier to support multi-region deployments and serverless environments. Serverless edge functions and lightweight container orchestration enables applications and business logic to be easily deployed globally, often leaving the database as the latency and scaling bottleneck. Join us to understand how PolyScale.ai solves these scaling challenges intelligently caching database data at the edge, without sacrificing transactionality or consistency. Get hands on with PolyScale for implementation, query observability and global latency testing with edge functions. Table of contents<ul><li>- Introduction to PolyScale.ai</li><li>- Enterprise Data Gravity</li><li>- Why data scaling is hard</li><li>- Options for Scaling the data tier</li><li>- Database Observability</li><li>- Cache Management AI</li><li>- Hands on with PolyScale.ai</li></ul><a href="https://www.froala.com/wysiwyg-editor?pb=1"></a>

Scaling Databases For Global Serverless Applications

Ben Hagan

GraphQL Galaxy

GraphQL Galaxy 2021

Maxime Beunier, a developer advocate at MongoDB, demonstrates how to build a serverless GraphQL API using MongoDB Atlas and Realm. He creates a new app called Galaxy, links it to the production cluster, and deploys it in Ireland. He then shows how to authenticate users and obtain a token to access the GraphQL API. The demo showcases the ease and speed of building a serverless GraphQL API and provides all the necessary links for further exploration.

<div>At the beginning of the COVID-19 pandemic, Johns Hopkins University worked on gathering and refining data from multiple sources and provided the world with a Github repository and a bunch of CSV files. The Problem? It’s nearly impossible to build anything from raw data like this.In this live coding session, MongoDB Developer Advocate Maxime Beugnet will show you how to build a serverless GraphQL API based on this dataset using Python and the MongoDB Data Platform. We are finally going to put serverless and the MongoDB generous free tier to good use!</div> <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building a Serverless GraphQL API in 7 Minutes

Maxime Beugnet

Today's workshop focused on serverless development with Fauna. The workshop covered topics such as building a client-serverless model, exploring data access patterns, and creating a serverless application. It also delved into user authentication, session management, and querying data in the front end. The workshop highlighted the power of Fauna for data manipulation and the flexibility it offers for building applications with fine-grained access control.

Welcome to Fauna! This workshop helps GraphQL developers build performant applications with Fauna that scale to any size userbase. You start with the basics, using only the GraphQL playground in the Fauna dashboard, then build a complete full-stack application with Next.js, adding functionality as you go along. In the first section, Getting started with Fauna, you learn how Fauna automatically creates queries, mutations, and other resources based on your GraphQL schema. You learn how to accomplish common tasks with GraphQL, how to use the Fauna Query Language (FQL) to perform more advanced tasks. In the second section, Building with Fauna, you learn how Fauna automatically creates queries, mutations, and other resources based on your GraphQL schema. You learn how to accomplish common tasks with GraphQL, how to use the Fauna Query Language (FQL) to perform more advanced tasks. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building a GraphQL-native serverless backend with Fauna

Rob Sutter

Shadid Haque

TestJS Summit

TestJS Summit 2021

Tundra is a tracing and debugging solution for applications, tests, CI pipelines, and workflows. It offers products like Tundra Foresight for monitoring CI-CD builds and Tundra APM for tracing and debugging microservices. Tundra provides distributed tracing, time travel debugging, and chaos engineering support. It helps troubleshoot test failures, identify and fix bugs, and simulate potential failures in production. Tundra supports Java, JavaScript, and Python runtimes, and integrates with popular CI providers.

In this workshop, we will be building a testing environment for a pre-built application, then we will write and automate end-to-end tests for our serverless application. And in the final step, we will demonstrate how easy it is to understand the root cause of an erroneous test using distributed testing and how to debug it in our CI/CD pipeline with Thundra Foresight. Table of contents: - How to set up and test your cloud infrastructure - How to write and automate end-to-end tests for your serverless workloads - How to debug, trace, and troubleshot test failures with Thundra Foresight in your CI/CD pipelines <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Live e2e test debugging for a distributed serverless application

Serkan Ozal

Oguzhan Ozdemir

React Advanced

React Advanced 2021

The Talk discusses building decentralized applications (DApps) with React and explores the benefits of smart contract technology. It highlights the characteristics and infrastructure of Web 3 applications, including decentralized indexing, off-chain data storage, and decentralized file storage. The Talk also covers identity in Web 3, with a focus on self-sovereign identity and the use of blockchain for identity verification. The process of building a DApp with React and Hard Hat is explained, along with deploying contracts and interacting with them. Overall, the Talk provides insights into the world of DApps and the technologies involved.

Decentralized apps (dApps) are continuing to gain momentum in the industry. These developers are also now some of the highest paid in the entire trade. Building decentralized apps is a paradigm shift that requires a different way of thinking than apps built with traditional centralized infrastructure, tooling, and services – taking into consideration things like game theory, decentralized serverless infrastructure, and cryptoeconomics. As a React developer, I initially had a hard time understanding this entirely new (to me) ecosystem, how everything fit together, and the mental model needed to understand and be a productive full stack developer in this space (and why I would consider it in the first place). In this talk, I'll give a comprehensive overview of the space, how you can get started building these types of applications, and the entire tech stack broken apart then put back together to show how everything works. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building Dapps with React

Nader Dabit

Node Congress 2021

This workshop focuses on learning serverless with TypeScript and building a serverless app for a coffee shop. It covers various topics such as serverless services and pricing, serverless workflow with AWS, setting up IAM and credentials, CDK project setup, organizing functions, and creating DynamoDB tables. The workshop also explores the benefits of a single-table layout in DynamoDB, creating APIs with AWS Lambda and API Gateway, and troubleshooting deployment issues. Additionally, it discusses environment variables, testing and debugging, and handling environments and rollbacks.

This workshop teaches you the basics of serverless application development with TypeScript. We'll start with a simple Lambda function, set up the project and the infrastructure-as-a-code (AWS CDK), and learn how to organize, test, and debug a more complex serverless application. Table of contents:<ul><li>        - How to set up a serverless project with TypeScript and CDK</li><li>        - How to write a testable Lambda function with hexagonal architecture</li><li>        - How to connect a function to a DynamoDB table</li><li>        - How to create a serverless API</li><li>        - How to debug and test a serverless function</li><li>        - How to organize and grow a serverless application Materials referred to in the workshop: <a href="https://excalidraw.com/#room=57b84e0df9bdb7ea5675,HYgVepLIpfxrK4EQNclQ9w" target="_blank">https://excalidraw.com/#room=57b84e0df9bdb7ea5675,HYgVepLIpfxrK4EQNclQ9w </a>DynamoDB blog Alex DeBrie: https://www.dynamodbguide.com/ Excellent book for the DynamoDB: <a href="https://www.dynamodbbook.com/" target="_blank">https://www.dynamodbbook.com/ https://slobodan.me/workshops/nodecongress/prerequisites.html </a></li></ul> <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Building Serverless Applications on AWS with TypeScript

DevOps.js Conf 2021

Welcome to the DevOpsJS conference where Jeff Hopper introduces his Slack bot called LGTM ReplyGIF for posting GIFs on his behalf. He troubleshoots issues with the serverless Node code, uses CloudWatch logs and stack traces for debugging, and ships logs to Elasticsearch for analysis. Jeff explores troubleshooting options with Rollbar and discusses serverless deployment recommendations. The audience is invited to contribute to the Slack bot project, and the session concludes with thanks from Jeff.

AWS ushered in a new landscape for deploying JavaScript applications using Node.js hosted in AWS Lambda, and since then the management simplicity that it provides has made serverless applications and APIs grow exponentially in both popularity and use cases. However, operationally for many starting out, troubleshooting issues can be painful. I'll walk through some techniques to make this easier and provide an evolution of how we can get to a better solution with tips and tools you can use in your serverless deployments right away. <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

Troubleshooting your Serverless Node.js doesn't have to be a Pain

Jeff Hoffer

Vacation Tracker is a serverless startup using Node.js that started with a simple lambda function and now has many lambda functions. They built a system connected to Slack and calendars, which is now used by many startups, companies, and organizations. They evolved to an event-driven architecture using CQRS and AWS AppSync with Managed GraphQL. Onboarding new developers is a challenge, but serverless allows them to assign a new environment and AWS account to each developer. Testing and monitoring are crucial, and they have successfully migrated from MongoDB to DynamoDB.

From 1 to 101 Lambda Functions in Production: Evolving a Serverless Architecture

TestJS Summit - January, 2021

The scariest thing about serverless is the fear of vendor lock-in and losing control. Planning, good architecture, and deployment procedures help keep switching costs reasonable. Hexagonal architecture is a useful approach for writing testable serverless apps. Integration testing is crucial for serverless apps, and hexagonal architecture helps fight vendor lock-in and reduce switching costs. Docker is used for testing serverless functions, and the practicality of hexagonal architecture remains a question.

According to many polls, testing serverless applications and fear of the cloud vendor lock-in are among the top five challenges organizations face when adopting serverless. We often hear that using serverless effectively requires a mind shift. But what does that mean? Do we need new tools and strategies for testing serverless applications, or can we use existing tools we already use for our non-serverless applications? And what about cloud vendor lock-in? Is that a real thing or just a fictional story that scares people away from serverless? Can we decrease a risk of vendor lock-in using a well-known architecture, such as hexagonal architecture? <a href="https://www.froala.com/wysiwyg-editor?pb=1"> </a>

#serverless