A presentation about my findings while tinkering with possibility of developing serverless microservices using Rust. Presented at Rust Meetup in Mozilla Indonesia, 8 September 2018.
This document discusses running CloudFoundry locally on a home server. It describes setting up a lightweight CloudFoundry environment tuned for an individual's needs, including support for Node.js, MongoDB, and mounting storage using CIFS/NFS. The goal is to gain the benefits of CloudFoundry while running everything locally on a personal server that is repaired easily using Chef deployment. A demo web UI is provided accessing text analysis applications deployed to this local CloudFoundry instance.
Vert.x is an asynchronous and non-blocking event-driven framework that allows building reactive applications on the JVM. It uses the reactor pattern and handles a large number of concurrent connections through asynchronous I/O without blocking threads. Applications can be written in Java or other JVM languages and deployed as microservices that communicate asynchronously through an event bus. This allows for easy horizontal scalability.
Using Serverless Architectures to build and provision modern infrastructuresRamit Surana
The document discusses serverless architectures using AWS Lambda. It introduces AWS Lambda as a serverless computing platform that runs code without provisioning or managing servers. Serverless architectures distribute API calls to stateless functions that leverage external cloud services for data. The document outlines the benefits of serverless, including scalability, low costs, and not having to manage servers. It also notes challenges like difficulty monitoring and debugging, lack of control, and vendor lock-in.
What does programming without servers look like? What are the possibilities? And how does it work? Wojciech Gawroński (Pattern Match) told us about it during the third meeting of Serverless User Group Poland, which took place on 27/09/2018 in Warsaw.
Wojtek's social media:
LinkedIN https://www.linkedin.com/in/afronski/
www https://pattern-match.com/
Serverless UG Poland
Facebook https://bit.ly/2zHuJeo
OpenNebula provides features for high availability of virtual machines including executing hooks if a host crashes and migrating or recreating VMs on failed hosts. It supports VM groups for VM to host, VM to VM, and role to role affinity. Network migrations can be optimized by routing through faster interfaces. Reusing predefined VLANs can be done by collecting used IDs from the database and returning the first free ID. Virtual machines can leverage cgroups for CPU management, pass raw parameters to hypervisors, and use guest agents to communicate with guests for tasks like freezing for consistent snapshots.
The document describes DemonWare's Consortium tool, which provides a centralized API for live operations datacenter management. Consortium allows defining all infrastructure elements as "nodes" with configurable attributes that can trigger automated operations. It uses a plugin architecture to interface with different backend systems. Version 2 improvements include separating the core from plugins, handling modifications asynchronously, and using Etcd and Arangodb instead of Redis. The transition planner processes proposed configuration changes by merging inputs from multiple providers and attempting to satisfy the desired state. The tool aims to standardize and simplify live operations tasks across different infrastructure systems.
Scaling and Orchestrating Microservices with OSGi - N Bartlettmfrancis
This document discusses how OSGi services can be used to implement microservices and enable their orchestration and scaling. It describes how OSGi services have supported capabilities like runtime assembly, software components, and continuous delivery since before the term "microservices" was coined. The document argues that OSGi services align with many characteristics of microservices, like independent deployability, but with OSGi additionally enforcing encapsulation where discipline is needed with other approaches. It also discusses how OSGi remote services and discovery allow services to be scaled horizontally across processes and machines while enabling dynamic availability and pluggability. The document demonstrates these concepts with an OSGi-based microservices orchestration platform.
Save 10% off ANY FITC event with discount code 'slideshare' - http://www.fitc.ca
OVERVIEW
Node.js is a runtime environment and library for running JavaScript applications outside the browser. Node.js is mostly used to run real-time server applications and shines through its performance using non-blocking I/O and asynchronous events. This talk will introduce you to Node.js by showcasing the environment and its two most popular libraries: express and socket.io.
TARGET AUDIENCE
Beginner web developers
ASSUMED AUDIENCE KNOWLEDGE
Working knowledge of JavaScript and HTML5.
OBJECTIVE
Learn how to build a chat engine using Node.js and WebSockets.
FIVE THINGS AUDIENCE MEMBERS WILL LEARN
Node.js environment and basics
Node Package Manager overview
Web Framework, express, basics
WebSockets and Socket.io basics
Building a chat engine using Node.js
This document discusses running CloudFoundry locally on a home server. It describes setting up a lightweight CloudFoundry environment tuned for an individual's needs, including support for Node.js, MongoDB, and mounting storage using CIFS/NFS. The goal is to gain the benefits of CloudFoundry while running everything locally on a personal server that is repaired easily using Chef deployment. A demo web UI is provided accessing text analysis applications deployed to this local CloudFoundry instance.
Vert.x is an asynchronous and non-blocking event-driven framework that allows building reactive applications on the JVM. It uses the reactor pattern and handles a large number of concurrent connections through asynchronous I/O without blocking threads. Applications can be written in Java or other JVM languages and deployed as microservices that communicate asynchronously through an event bus. This allows for easy horizontal scalability.
Using Serverless Architectures to build and provision modern infrastructuresRamit Surana
The document discusses serverless architectures using AWS Lambda. It introduces AWS Lambda as a serverless computing platform that runs code without provisioning or managing servers. Serverless architectures distribute API calls to stateless functions that leverage external cloud services for data. The document outlines the benefits of serverless, including scalability, low costs, and not having to manage servers. It also notes challenges like difficulty monitoring and debugging, lack of control, and vendor lock-in.
What does programming without servers look like? What are the possibilities? And how does it work? Wojciech Gawroński (Pattern Match) told us about it during the third meeting of Serverless User Group Poland, which took place on 27/09/2018 in Warsaw.
Wojtek's social media:
LinkedIN https://www.linkedin.com/in/afronski/
www https://pattern-match.com/
Serverless UG Poland
Facebook https://bit.ly/2zHuJeo
OpenNebula provides features for high availability of virtual machines including executing hooks if a host crashes and migrating or recreating VMs on failed hosts. It supports VM groups for VM to host, VM to VM, and role to role affinity. Network migrations can be optimized by routing through faster interfaces. Reusing predefined VLANs can be done by collecting used IDs from the database and returning the first free ID. Virtual machines can leverage cgroups for CPU management, pass raw parameters to hypervisors, and use guest agents to communicate with guests for tasks like freezing for consistent snapshots.
The document describes DemonWare's Consortium tool, which provides a centralized API for live operations datacenter management. Consortium allows defining all infrastructure elements as "nodes" with configurable attributes that can trigger automated operations. It uses a plugin architecture to interface with different backend systems. Version 2 improvements include separating the core from plugins, handling modifications asynchronously, and using Etcd and Arangodb instead of Redis. The transition planner processes proposed configuration changes by merging inputs from multiple providers and attempting to satisfy the desired state. The tool aims to standardize and simplify live operations tasks across different infrastructure systems.
Scaling and Orchestrating Microservices with OSGi - N Bartlettmfrancis
This document discusses how OSGi services can be used to implement microservices and enable their orchestration and scaling. It describes how OSGi services have supported capabilities like runtime assembly, software components, and continuous delivery since before the term "microservices" was coined. The document argues that OSGi services align with many characteristics of microservices, like independent deployability, but with OSGi additionally enforcing encapsulation where discipline is needed with other approaches. It also discusses how OSGi remote services and discovery allow services to be scaled horizontally across processes and machines while enabling dynamic availability and pluggability. The document demonstrates these concepts with an OSGi-based microservices orchestration platform.
Save 10% off ANY FITC event with discount code 'slideshare' - http://www.fitc.ca
OVERVIEW
Node.js is a runtime environment and library for running JavaScript applications outside the browser. Node.js is mostly used to run real-time server applications and shines through its performance using non-blocking I/O and asynchronous events. This talk will introduce you to Node.js by showcasing the environment and its two most popular libraries: express and socket.io.
TARGET AUDIENCE
Beginner web developers
ASSUMED AUDIENCE KNOWLEDGE
Working knowledge of JavaScript and HTML5.
OBJECTIVE
Learn how to build a chat engine using Node.js and WebSockets.
FIVE THINGS AUDIENCE MEMBERS WILL LEARN
Node.js environment and basics
Node Package Manager overview
Web Framework, express, basics
WebSockets and Socket.io basics
Building a chat engine using Node.js
This document discusses Nashorn, a JavaScript engine for Java 8 that replaced the older Rhino engine. It provides an overview of Nashorn's features like improved performance and ECMAScript compliance compared to Rhino. It also introduces Avatar.js, an open source framework that brings the Node.js programming model to the JVM using Nashorn. Finally, it briefly describes Project Avatar, which provides JavaScript services and client frameworks to build applications using Nashorn and Avatar.js that integrate with Java platforms and APIs.
Are you still using FTP to deploy your code? Are you still manually performing the same steps of deploying a feature, again and again? How many hours have you spent on ssh-ing into the server, pulling the repo, migrating the database, reloading the web server and so on, for each deployment?? Ever wondered if there is a process as simple as a single click to perform all these steps for you?
Automated Deployment does exactly these things for you. It takes the burden of remembering all the steps required in each deployment process and execute it smoothly.
Sascha Möllering discusses how his company moved from manual server setup and deployment to automated deployments using infrastructure as code and continuous delivery. They now deploy whenever needed using tools like Chef and JBoss to configure servers. Previously they faced challenges like manual processes, difficult rollbacks, and biweekly deployment windows. Now deployments are automated, safer, and can happen continuously.
Containerization allows for standardized and isolated application deployment across infrastructure through container runtimes like Docker. Key features that enable containers include namespaces which isolate processes and their views of the system, cgroups which control resource usage, and copy-on-write storage for efficient application packaging. A container orchestration system like Mesos provides scalability, fault tolerance, and unified resource management across clusters. This allows maximizing infrastructure utilization through flexible scheduling of containerized applications and services on shared clusters.
The document discusses automating server provisioning and configuration using Ansible playbooks. It recommends developing playbooks using Vagrant to easily create, boot, and destroy virtual machines. Playbooks can then be run against real servers on Red Hat to provision them in a repeatable, documented process. Lessons learned are that Ansible playbooks serve as great infrastructure documentation and help refine the setup, and it's important to ensure playbooks are idempotent and prefer using modules over raw commands.
Amazon Cloud Hands-On provides an overview of Amazon Web Services including Elastic Compute Cloud (EC2) for computing resources, Simple Storage Service (S3) for storage, and Simple Queue Service (SQS) for message queuing. EC2 allows scaling computing power up or down within minutes and starts at 10 cents per hour for 1 EC unit equal to 1.7 GHz x86 processor and 1.7 GB RAM. S3 stores objects up to 5GB in size with SOAP and REST interfaces and affordable pricing, while SQS retains messages for 4 days with a maximum size of 8KB and supports SOAP and queries.
Service Discovery in OSGi: Beyond the JVM using Docker and ConsulFrank Lyaruu
OSGi offers an excellent service discovery mechanism, but it is limited to services inside the JVM. With Docker nowadays it is trivially easy to deploy all kind of (micro) services, so we’d like to discover those too. We will have a look at how we can use the Docker API to discover services in other containers, and how we can use Consul to expand service discovery to other hosts.
ApacheCon Core: Service Discovery in OSGi: Beyond the JVM using Docker and Co...Frank Lyaruu
OSGi offers an excellent service discovery mechanism, but it is limited to services inside the JVM. With Docker nowadays it is trivially easy to deploy all kind of (micro) services, using pretty much any technology stack, so we’d like to discover those as easily as the ones inside the JVM. We will have a look at how we can use the Docker API to discover services in other containers, and how we can use Consul to expand service discovery to other hosts.
Node.js architecture is all about managing the incoming requests and providing an appropriate response to each of those requests. This article dives deeper into the working of Node.js and the workflow of the whole server environment.
This document provides an introduction to microservices and Docker containers. It defines microservices as loosely coupled elements that have bounded contexts, and notes they evolve service-oriented architecture and apply the Unix philosophy to application systems. Docker is described as a library and ecosystem for creating and sharing containers built from Linux features to package applications and dependencies into single binaries. Reasons for using Docker/containers with microservices include self-contained images that allow running thousands of containers across hardware topologies. Challenges with microservices architectures at scale are also discussed.
DockerCon 2015: Docker Engine Breakout SessionDocker, Inc.
The document summarizes a Docker Engine breakout session that covered:
- An overview of Docker Engine, including key facts about its contributors and development.
- New features in Docker Engine 1.7.0, including an experimental binary, a new networking model, and improved network performance.
- Upcoming priorities like better tooling, security enhancements, and improved management of networks and volumes.
A demo was also planned to showcase Docker Engine capabilities.
This document discusses using scripting languages in OSGi. It describes how to dynamically add, modify, and remove scripts as OSGi bundles by generating bundles from scripts, exposing the scripts as OSGi services, and allowing declarative dependencies. Key points covered include using the JSR-223 Scripting API, generating bundle and manifest files, exposing services through Declarative Services, determining dependencies, and compiling scripts in OSGi. The presentation concludes that combining scripting languages and OSGi bundles is possible but has some challenges around determining dependencies and classloading.
Hashicorp: Delivering the Tao of DevOpsRamit Surana
HashiCorp is an open-source software company based in San Francisco, California that solves development, operations, and security challenges in infrastructure so organizations can focus on business-critical tasks. HashiCorp provides a set of open source tools and commercial product offerings.
"Microservices" is one of the hottest buzzwords and, as usual, everyone wants them, but few know how to build them. In this talk we will offer our interpretation of microservice architecture, and show how we are implementing these ideas: using Scala, Akka, sbt and Docker, we modularized Akka applications, Spark jobs and Play servers.
In the talk we will discuss design trade-offs and challenges that we faced in the process, and how we have overcome them. The focus is not on particular features of Scala language or a library, but on building modern applications using the Typesafe stack and other open-source tools.
DockerCon SF 2015: Networking BreakoutDocker, Inc.
This document provides an overview of Docker's new networking capabilities through libnetwork. It introduces libnetwork, which provides a pluggable driver-based networking stack for containers. Libnetwork implements the Container Network Model and provides APIs for creating and managing networks and endpoints. It supports multiple networking drivers like bridge and overlay. The goals are to make networking and services first-class objects in Docker and span networks across multiple hosts. The presentation encourages trying the new networking features in Docker experimental and contributing to libnetwork.
The presentation was made at the first Serverless Pune meetup on 4th Feb 2017 https://www.meetup.com/Serverless-Pune
In the first Meetup, we covered most of the basics & a simple demos. Upcoming meetups will dive deeper into technical implementation and various real world use cases
This document discusses several Platform as a Service (PaaS) alternatives for .NET applications. It describes what PaaS is and some of the challenges it presents. It then evaluates several specific PaaS options for .NET including Apprenda, CloudFoundry, Uhuru, Tier3, AppHarbor, and AWS Elastic Beanstalk. It concludes that Windows Azure is still the best public PaaS for .NET, but that CloudFoundry-based private PaaS solutions are worth considering to avoid vendor lock-in.
Armeria is an open-source asynchronous HTTP/2 RPC/REST client/server library built on Java 8, Netty, Thrift and gRPC. It helps build high-performance asynchronous microservices using HTTP/2 as the session layer protocol. Recent features include modularity with separate modules like core, thrift and grpc, improved Spring support with auto-configuration and starters, gRPC support through services and enhancements, and dynamic multi-backend support using technologies like ZooKeeper and DNS.
Rami Sayar - Node microservices with DockerWeb à Québec
The document discusses converting a monolithic Node.js application into microservices and deploying them using Docker. It begins by defining microservices and their benefits. It then describes converting a sample pizza ordering application into independent microservices for handling messages, serving the frontend, and providing an API. Next, it covers patterns for networking microservices, including using an API gateway. It concludes by demonstrating how to deploy the microservices to Docker containers and use an orchestration tool like Kubernetes to manage them.
Best Practices for Running Kafka on Docker ContainersBlueData, Inc.
Docker containers provide an ideal foundation for running Kafka-as-a-Service on-premises or in the public cloud. However, using Docker containers in production environments for Big Data workloads using Kafka poses some challenges – including container management, scheduling, network configuration and security, and performance.
In this session at Kafka Summit in August 2017, Nanda Vijyaydev of BlueData shared lessons learned from implementing Kafka-as-a-Service with Docker containers.
https://kafka-summit.org/sessions/kafka-service-docker-containers
This document discusses Nashorn, a JavaScript engine for Java 8 that replaced the older Rhino engine. It provides an overview of Nashorn's features like improved performance and ECMAScript compliance compared to Rhino. It also introduces Avatar.js, an open source framework that brings the Node.js programming model to the JVM using Nashorn. Finally, it briefly describes Project Avatar, which provides JavaScript services and client frameworks to build applications using Nashorn and Avatar.js that integrate with Java platforms and APIs.
Are you still using FTP to deploy your code? Are you still manually performing the same steps of deploying a feature, again and again? How many hours have you spent on ssh-ing into the server, pulling the repo, migrating the database, reloading the web server and so on, for each deployment?? Ever wondered if there is a process as simple as a single click to perform all these steps for you?
Automated Deployment does exactly these things for you. It takes the burden of remembering all the steps required in each deployment process and execute it smoothly.
Sascha Möllering discusses how his company moved from manual server setup and deployment to automated deployments using infrastructure as code and continuous delivery. They now deploy whenever needed using tools like Chef and JBoss to configure servers. Previously they faced challenges like manual processes, difficult rollbacks, and biweekly deployment windows. Now deployments are automated, safer, and can happen continuously.
Containerization allows for standardized and isolated application deployment across infrastructure through container runtimes like Docker. Key features that enable containers include namespaces which isolate processes and their views of the system, cgroups which control resource usage, and copy-on-write storage for efficient application packaging. A container orchestration system like Mesos provides scalability, fault tolerance, and unified resource management across clusters. This allows maximizing infrastructure utilization through flexible scheduling of containerized applications and services on shared clusters.
The document discusses automating server provisioning and configuration using Ansible playbooks. It recommends developing playbooks using Vagrant to easily create, boot, and destroy virtual machines. Playbooks can then be run against real servers on Red Hat to provision them in a repeatable, documented process. Lessons learned are that Ansible playbooks serve as great infrastructure documentation and help refine the setup, and it's important to ensure playbooks are idempotent and prefer using modules over raw commands.
Amazon Cloud Hands-On provides an overview of Amazon Web Services including Elastic Compute Cloud (EC2) for computing resources, Simple Storage Service (S3) for storage, and Simple Queue Service (SQS) for message queuing. EC2 allows scaling computing power up or down within minutes and starts at 10 cents per hour for 1 EC unit equal to 1.7 GHz x86 processor and 1.7 GB RAM. S3 stores objects up to 5GB in size with SOAP and REST interfaces and affordable pricing, while SQS retains messages for 4 days with a maximum size of 8KB and supports SOAP and queries.
Service Discovery in OSGi: Beyond the JVM using Docker and ConsulFrank Lyaruu
OSGi offers an excellent service discovery mechanism, but it is limited to services inside the JVM. With Docker nowadays it is trivially easy to deploy all kind of (micro) services, so we’d like to discover those too. We will have a look at how we can use the Docker API to discover services in other containers, and how we can use Consul to expand service discovery to other hosts.
ApacheCon Core: Service Discovery in OSGi: Beyond the JVM using Docker and Co...Frank Lyaruu
OSGi offers an excellent service discovery mechanism, but it is limited to services inside the JVM. With Docker nowadays it is trivially easy to deploy all kind of (micro) services, using pretty much any technology stack, so we’d like to discover those as easily as the ones inside the JVM. We will have a look at how we can use the Docker API to discover services in other containers, and how we can use Consul to expand service discovery to other hosts.
Node.js architecture is all about managing the incoming requests and providing an appropriate response to each of those requests. This article dives deeper into the working of Node.js and the workflow of the whole server environment.
This document provides an introduction to microservices and Docker containers. It defines microservices as loosely coupled elements that have bounded contexts, and notes they evolve service-oriented architecture and apply the Unix philosophy to application systems. Docker is described as a library and ecosystem for creating and sharing containers built from Linux features to package applications and dependencies into single binaries. Reasons for using Docker/containers with microservices include self-contained images that allow running thousands of containers across hardware topologies. Challenges with microservices architectures at scale are also discussed.
DockerCon 2015: Docker Engine Breakout SessionDocker, Inc.
The document summarizes a Docker Engine breakout session that covered:
- An overview of Docker Engine, including key facts about its contributors and development.
- New features in Docker Engine 1.7.0, including an experimental binary, a new networking model, and improved network performance.
- Upcoming priorities like better tooling, security enhancements, and improved management of networks and volumes.
A demo was also planned to showcase Docker Engine capabilities.
This document discusses using scripting languages in OSGi. It describes how to dynamically add, modify, and remove scripts as OSGi bundles by generating bundles from scripts, exposing the scripts as OSGi services, and allowing declarative dependencies. Key points covered include using the JSR-223 Scripting API, generating bundle and manifest files, exposing services through Declarative Services, determining dependencies, and compiling scripts in OSGi. The presentation concludes that combining scripting languages and OSGi bundles is possible but has some challenges around determining dependencies and classloading.
Hashicorp: Delivering the Tao of DevOpsRamit Surana
HashiCorp is an open-source software company based in San Francisco, California that solves development, operations, and security challenges in infrastructure so organizations can focus on business-critical tasks. HashiCorp provides a set of open source tools and commercial product offerings.
"Microservices" is one of the hottest buzzwords and, as usual, everyone wants them, but few know how to build them. In this talk we will offer our interpretation of microservice architecture, and show how we are implementing these ideas: using Scala, Akka, sbt and Docker, we modularized Akka applications, Spark jobs and Play servers.
In the talk we will discuss design trade-offs and challenges that we faced in the process, and how we have overcome them. The focus is not on particular features of Scala language or a library, but on building modern applications using the Typesafe stack and other open-source tools.
DockerCon SF 2015: Networking BreakoutDocker, Inc.
This document provides an overview of Docker's new networking capabilities through libnetwork. It introduces libnetwork, which provides a pluggable driver-based networking stack for containers. Libnetwork implements the Container Network Model and provides APIs for creating and managing networks and endpoints. It supports multiple networking drivers like bridge and overlay. The goals are to make networking and services first-class objects in Docker and span networks across multiple hosts. The presentation encourages trying the new networking features in Docker experimental and contributing to libnetwork.
The presentation was made at the first Serverless Pune meetup on 4th Feb 2017 https://www.meetup.com/Serverless-Pune
In the first Meetup, we covered most of the basics & a simple demos. Upcoming meetups will dive deeper into technical implementation and various real world use cases
This document discusses several Platform as a Service (PaaS) alternatives for .NET applications. It describes what PaaS is and some of the challenges it presents. It then evaluates several specific PaaS options for .NET including Apprenda, CloudFoundry, Uhuru, Tier3, AppHarbor, and AWS Elastic Beanstalk. It concludes that Windows Azure is still the best public PaaS for .NET, but that CloudFoundry-based private PaaS solutions are worth considering to avoid vendor lock-in.
Armeria is an open-source asynchronous HTTP/2 RPC/REST client/server library built on Java 8, Netty, Thrift and gRPC. It helps build high-performance asynchronous microservices using HTTP/2 as the session layer protocol. Recent features include modularity with separate modules like core, thrift and grpc, improved Spring support with auto-configuration and starters, gRPC support through services and enhancements, and dynamic multi-backend support using technologies like ZooKeeper and DNS.
Rami Sayar - Node microservices with DockerWeb à Québec
The document discusses converting a monolithic Node.js application into microservices and deploying them using Docker. It begins by defining microservices and their benefits. It then describes converting a sample pizza ordering application into independent microservices for handling messages, serving the frontend, and providing an API. Next, it covers patterns for networking microservices, including using an API gateway. It concludes by demonstrating how to deploy the microservices to Docker containers and use an orchestration tool like Kubernetes to manage them.
Best Practices for Running Kafka on Docker ContainersBlueData, Inc.
Docker containers provide an ideal foundation for running Kafka-as-a-Service on-premises or in the public cloud. However, using Docker containers in production environments for Big Data workloads using Kafka poses some challenges – including container management, scheduling, network configuration and security, and performance.
In this session at Kafka Summit in August 2017, Nanda Vijyaydev of BlueData shared lessons learned from implementing Kafka-as-a-Service with Docker containers.
https://kafka-summit.org/sessions/kafka-service-docker-containers
Node.js 101 with Rami Sayar
Presented on September 18 2014 at
FITC's Web Unleashed Toronto 2014 Conference
More info at www.fitc.ca
OVERVIEW
Node.js is a runtime environment and library for running JavaScript applications outside the browser. Node.js is mostly used to run real-time server applications and shines through its performance using non-blocking I/O and asynchronous events. This talk will introduce you to Node.js by showcasing the environment and its two most popular libraries: express and socket.io.
TARGET AUDIENCE
Beginner web developers
ASSUMED AUDIENCE KNOWLEDGE
Working knowledge of JavaScript and HTML5.
OBJECTIVE
Learn how to build a chat engine using Node.js and WebSockets.
FIVE THINGS AUDIENCE MEMBERS WILL LEARN
Node.js environment and basics
Node Package Manager overview
Web Framework, express, basics
WebSockets and Socket.io basics
Building a chat engine using Node.js
The document outlines the agenda for the OpenStack Summit in November 2013, including presentations on Docker and its ecosystem, how Docker can be used with OpenStack and Rackspace, and a demonstration of cross-cloud application deployment using Docker. Docker is presented as a solution to the "matrix from hell" of running applications across different environments by providing lightweight, portable containers that can run anywhere regardless of the operating system. The summit aims to educate attendees on Docker and showcase its integration with OpenStack for simplified and efficient application deployment and management across multiple clouds.
The document provides an introduction to Docker, containers, and the problems they aim to solve. It discusses:
- Why Docker was created - to address the "matrix from hell" of developing and deploying applications across different environments and platforms.
- How Docker works at a high level, using lightweight containers that package code and dependencies to run consistently on any infrastructure.
- Some key Docker concepts like images, containers, the Dockerfile for building images, and common Docker commands.
- Benefits of Docker for developers and operations in simplifying deployment, reducing inconsistencies, and improving portability of applications.
This document discusses ForgeRock's DevOps and cloud strategy. It outlines ForgeRock's goal of providing the agility of an identity-as-a-service solution with the flexibility of a custom solution. It describes what makes products "DevOps friendly" and focuses on making ForgeRock's products more container and cloud friendly. The roadmap sections outline planned improvements to OpenAM, OpenDJ, and OpenIDM to reduce dependencies and improve automation. It closes with a request for customer feedback to help prioritize efforts.
This document summarizes Docker, an open-source containerization platform. It discusses Docker's rapid growth since its launch 1 year prior, with over 370 contributors and 1 million downloads. Docker addresses the challenge of running applications across different environments by allowing applications and their dependencies to run in isolated containers that can be moved between servers. This eliminates inconsistencies between development and production environments. The document outlines benefits of Docker for developers, operations teams, and its role in microservices architecture.
Docker containers have been making inroads into Windows and Azure world. Docker has now replaced the traditional Azure IaaS & PaaS services, offering superior container versions which are more responsive, cost effective, and agile. In this session for Charlotte Azure User Group, we will take an in-depth look at the intersection of Docker and Azure, and how Docker is empowering next gen Azure services.
Here's the link to CAG meetup for the event - https://www.meetup.com/Charlotte-Microsoft-Azure/events/fpftgmyxjbjb/
This document discusses microservices architecture patterns and practices. It begins with an introduction and definitions of microservices. Key advantages of microservices include improved maintainability, testability, and scalability. The document covers topics such as decomposing monolithic applications into microservices based on business capabilities or domains, approaches to data management and communication between services, deployment requirements, and using Docker for deployment.
This presentation has been given during DevOps Congress in Wrocław. It is about container orchestrations with Docker Swarm and Traefik. It includes the configuration examples of Traefik version 2.0.
The source code used in the presentation: https://github.com/jakubhajek/traefik-swarm
This document discusses containers and Docker. It begins by explaining that cloud infrastructures comprise virtual resources like compute and storage nodes that are administered through software. Docker is introduced as a standard way to package code and dependencies into portable containers that can run anywhere. Key benefits of Docker include increased efficiency, consistency, and security compared to traditional virtual machines. Some weaknesses are that Docker may not be suitable for all applications and large container management can be difficult. Interesting uses of Docker include malware analysis sandboxes, isolating Skype sessions, and managing Raspberry Pi clusters with Docker Swarm.
A brief introduction to containerization, Docker, and getting started with your first containerized Rails application. Source code can be found at https://github.com/rheinwein/rails-demo-apps
The document discusses serverless computing and OpenFaaS, an open source serverless framework. It introduces serverless functions and how OpenFaaS allows developers to easily write and deploy stateless functions. The document provides examples of how functions can be chained together and invoked asynchronously. It also shares several case studies of organizations using OpenFaaS and announces the launch of OpenFaaS Cloud.
Serverless computing is an emerging cloud computing model where the cloud provider manages resources and scales applications automatically in response to demand. With serverless, developers focus on writing code for independent, stateless functions rather than worrying about servers. Serverless platforms support automatic scaling, pay-per-use pricing, and event-driven computing using functions as the basic unit. While serverless offers benefits like reduced costs and management overhead, it also presents drawbacks like vendor lock-in and lack of debugging access.
Docker is not just about deploying containers to hundreds of servers. Developers need tools that help with day-to-day tasks and to do their job more effectively. Docker is a great addition to most workflows, from starting projects to writing utilities to make development less repetitive. Docker can help take care of many problems developers face during development such as “it works on my machine” as well as keeping tooling consistent between all of the people working on a project. See how easy it is to take an existing development setup and application and move it over to Docker, no matter your operating system.
Orchestrating Linux Containers while tolerating failuresDocker, Inc.
lthough containers are bringing a refreshing flexibility when deploying services in production, the management of those containers in such an environment still requires special care in order to keep the application up and running. In this regard, orchestration platforms like Docker, Kubernetes and Nomad have been trying to alleviate this responsibility, facilitating the task of deploying and maintaining the entire application stack in its desired state. This ensures that a service will be always running, tolerating machine failures, network erratic behavior or software updates and downtime. The purpose of this talk is to explain the mechanisms and architecture of the Docker Engine orchestration platform (using a framework called swarmkit) to tolerate failures of services and machines, from cluster state replication and leader-election to container re-scheduling logic when a host goes down.
This document discusses real-time web applications and technologies. It defines real-time apps as allowing bi-directional communication between clients and servers so that users receive information as soon as it is published. Examples include chat, social media, gaming and notifications. Key implementation methods discussed are HTTP polling, streaming and WebSockets. The document also surveys popular real-time libraries for publish/subscribe, data syncing and hybrid approaches.
Write Once and REALLY Run Anywhere | OpenStack Summit HK 2013dotCloud
The document outlines the agenda for the OpenStack Summit in November 2013. The agenda includes sessions on Docker and its ecosystem, using Docker with OpenStack and Rackspace, and a cross-cloud deployment demo. Docker is presented as a solution for developing and deploying applications across multiple environments by encapsulating code and dependencies in portable containers. It can help eliminate inconsistencies between development, testing, and production environments.
Similar to Developing Serverless Microservice in Rust (20)
Managing Infrastructure as a Product - Introduction to Platform EngineeringAdityo Pratomo
This is an introduction to platform engineering, the bridge that truly fulfills DevOps potential inside a mid-large scale organization. Sure, it's all the rage these days, but I'd argue to completely develop a platform, a product thinking mindset is also required.
This talk was presented in Kubernetes Day Indonesia 2022
A talk about how designer and developer can start work in a more unified flow, breaking the silo between them and get to code as soon as possible when designing UI. This was presented at JSDay Indonesia 2019.
The document discusses virtual private assistants and how they can help automate mundane and repetitive tasks. It describes how virtual assistants can be applications, chatbots, or specialized hardware that act as personal assistants to help with daily activities like checking schedules, paying bills, and more. The document provides an example of using a chatbot named Meekan in Slack to easily schedule meetings between team members by accessing calendars and sending invitations. It outlines the components needed to build a virtual assistant like connecting it to third party services through APIs and using chatbot SDKs and NLP tools. The presentation encourages automating tasks with virtual assistants to increase productivity.
Rust is a systems programming language that is a lower-level alternative to Go and Python, providing memory safety without garbage collection. It is useful for applications that need high performance like operating systems, games, and embedded software. Some key features of Rust include its borrowing system that ensures only one mutable reference to data exists at a time, eliminating data races and preventing security issues. The talk provided an introduction to Rust syntax like variables, functions, structs and vectors to demonstrate how Rust enforces memory safety through its ownership and borrowing rules at compile time.
A short overview on VR, developing it in Unity and various tips for interaction and performance.
This is presented in ProCodeCG's codeMeetUp() on 15 August 2016
Empowering Users: UX Lesson from Game DesignAdityo Pratomo
This is a presentation from a recent UX ID meetup, where I pointed several lesson from game design that any UX designers can learn from in terms of empowering the user of their products
This slide describes our proposition of concept regarding an OS wide user interface for free gestures input devices such as Leap Motion. This was presented in GNOME Asia 2015 on 9th May 2015. We discusses how we tackle the design issue and our prototype of the concept implemented in GNOME and browser.
Coding as Intersection of Art and TechnologyAdityo Pratomo
This slide is presented during my talk at TEDxTelkomU, 15 December 2013. It's about how I view coding as an intersection of art and technology and how practicing it for art purpose actually increases my then mediocre skill at programming.
Interactive Data Visualization with Tangible User InterfaceAdityo Pratomo
The slide looks into describing data visualization from an art perspective to communicate the research findings regarding how temperature changes affect the life of coral.
A tangible user interface is used to interact with the data to create an engaging experience for the audience of the artwork.
The document summarizes research findings for designing a public display called the Grid Gallery. It includes the following:
1) Observation research found that office workers are the main audience during the day and more people walk in the area in the evenings after work hours.
2) User surveys indicated that the display should be inviting, provoke interaction, be enjoyable for audiences, and connect people with the space in a simple way.
3) Paper research on connecting people via public displays emphasized designing for social interaction and engagement between spectators and participators.
4) The design requirements call for the display to connect audiences with others, engage both spectators across the gallery and participators in front of it, and create an
The document summarizes research conducted for a public display called the Grid Gallery. It includes observations of people in the area, interviews, and a survey. The research found that office workers are the main audience and more people walk by after work hours when they are relaxed. The design requirements are to connect audiences with others, engage spectators from a distance and participators up close, create an engaging display, and involve social interaction for multiple users.
In our second session, we shall learn all about the main features and fundamentals of UiPath Studio that enable us to use the building blocks for any automation project.
📕 Detailed agenda:
Variables and Datatypes
Workflow Layouts
Arguments
Control Flows and Loops
Conditional Statements
💻 Extra training through UiPath Academy:
Variables, Constants, and Arguments in Studio
Control Flow in Studio
From Natural Language to Structured Solr Queries using LLMsSease
This talk draws on experimentation to enable AI applications with Solr. One important use case is to use AI for better accessibility and discoverability of the data: while User eXperience techniques, lexical search improvements, and data harmonization can take organizations to a good level of accessibility, a structural (or “cognitive” gap) remains between the data user needs and the data producer constraints.
That is where AI – and most importantly, Natural Language Processing and Large Language Model techniques – could make a difference. This natural language, conversational engine could facilitate access and usage of the data leveraging the semantics of any data source.
The objective of the presentation is to propose a technical approach and a way forward to achieve this goal.
The key concept is to enable users to express their search queries in natural language, which the LLM then enriches, interprets, and translates into structured queries based on the Solr index’s metadata.
This approach leverages the LLM’s ability to understand the nuances of natural language and the structure of documents within Apache Solr.
The LLM acts as an intermediary agent, offering a transparent experience to users automatically and potentially uncovering relevant documents that conventional search methods might overlook. The presentation will include the results of this experimental work, lessons learned, best practices, and the scope of future work that should improve the approach and make it production-ready.
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectorsDianaGray10
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
Northern Engraving | Nameplate Manufacturing Process - 2024Northern Engraving
Manufacturing custom quality metal nameplates and badges involves several standard operations. Processes include sheet prep, lithography, screening, coating, punch press and inspection. All decoration is completed in the flat sheet with adhesive and tooling operations following. The possibilities for creating unique durable nameplates are endless. How will you create your brand identity? We can help!
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor IvaniukFwdays
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
"What does it really mean for your system to be available, or how to define w...Fwdays
We will talk about system monitoring from a few different angles. We will start by covering the basics, then discuss SLOs, how to define them, and why understanding the business well is crucial for success in this exercise.
Introducing BoxLang : A new JVM language for productivity and modularity!Ortus Solutions, Corp
Just like life, our code must adapt to the ever changing world we live in. From one day coding for the web, to the next for our tablets or APIs or for running serverless applications. Multi-runtime development is the future of coding, the future is to be dynamic. Let us introduce you to BoxLang.
Dynamic. Modular. Productive.
BoxLang redefines development with its dynamic nature, empowering developers to craft expressive and functional code effortlessly. Its modular architecture prioritizes flexibility, allowing for seamless integration into existing ecosystems.
Interoperability at its Core
With 100% interoperability with Java, BoxLang seamlessly bridges the gap between traditional and modern development paradigms, unlocking new possibilities for innovation and collaboration.
Multi-Runtime
From the tiny 2m operating system binary to running on our pure Java web server, CommandBox, Jakarta EE, AWS Lambda, Microsoft Functions, Web Assembly, Android and more. BoxLang has been designed to enhance and adapt according to it's runnable runtime.
The Fusion of Modernity and Tradition
Experience the fusion of modern features inspired by CFML, Node, Ruby, Kotlin, Java, and Clojure, combined with the familiarity of Java bytecode compilation, making BoxLang a language of choice for forward-thinking developers.
Empowering Transition with Transpiler Support
Transitioning from CFML to BoxLang is seamless with our JIT transpiler, facilitating smooth migration and preserving existing code investments.
Unlocking Creativity with IDE Tools
Unleash your creativity with powerful IDE tools tailored for BoxLang, providing an intuitive development experience and streamlining your workflow. Join us as we embark on a journey to redefine JVM development. Welcome to the era of BoxLang.
[OReilly Superstream] Occupy the Space: A grassroots guide to engineering (an...Jason Yip
The typical problem in product engineering is not bad strategy, so much as “no strategy”. This leads to confusion, lack of motivation, and incoherent action. The next time you look for a strategy and find an empty space, instead of waiting for it to be filled, I will show you how to fill it in yourself. If you’re wrong, it forces a correction. If you’re right, it helps create focus. I’ll share how I’ve approached this in the past, both what works and lessons for what didn’t work so well.
"NATO Hackathon Winner: AI-Powered Drug Search", Taras KlobaFwdays
This is a session that details how PostgreSQL's features and Azure AI Services can be effectively used to significantly enhance the search functionality in any application.
In this session, we'll share insights on how we used PostgreSQL to facilitate precise searches across multiple fields in our mobile application. The techniques include using LIKE and ILIKE operators and integrating a trigram-based search to handle potential misspellings, thereby increasing the search accuracy.
We'll also discuss how the azure_ai extension on PostgreSQL databases in Azure and Azure AI Services were utilized to create vectors from user input, a feature beneficial when users wish to find specific items based on text prompts. While our application's case study involves a drug search, the techniques and principles shared in this session can be adapted to improve search functionality in a wide range of applications. Join us to learn how PostgreSQL and Azure AI can be harnessed to enhance your application's search capability.
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Keywords: AI, Containeres, Kubernetes, Cloud Native
Event Link: https://meine.doag.org/events/cloudland/2024/agenda/#agendaId.4211
AI in the Workplace Reskilling, Upskilling, and Future Work.pptxSunil Jagani
Discover how AI is transforming the workplace and learn strategies for reskilling and upskilling employees to stay ahead. This comprehensive guide covers the impact of AI on jobs, essential skills for the future, and successful case studies from industry leaders. Embrace AI-driven changes, foster continuous learning, and build a future-ready workforce.
Read More - https://bit.ly/3VKly70
QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...AlexanderRichford
QR Secure: A Hybrid Approach Using Machine Learning and Security Validation Functions to Prevent Interaction with Malicious QR Codes.
Aim of the Study: The goal of this research was to develop a robust hybrid approach for identifying malicious and insecure URLs derived from QR codes, ensuring safe interactions.
This is achieved through:
Machine Learning Model: Predicts the likelihood of a URL being malicious.
Security Validation Functions: Ensures the derived URL has a valid certificate and proper URL format.
This innovative blend of technology aims to enhance cybersecurity measures and protect users from potential threats hidden within QR codes 🖥 🔒
This study was my first introduction to using ML which has shown me the immense potential of ML in creating more secure digital environments!
Getting the Most Out of ScyllaDB Monitoring: ShareChat's TipsScyllaDB
ScyllaDB monitoring provides a lot of useful information. But sometimes it’s not easy to find the root of the problem if something is wrong or even estimate the remaining capacity by the load on the cluster. This talk shares our team's practical tips on: 1) How to find the root of the problem by metrics if ScyllaDB is slow 2) How to interpret the load and plan capacity for the future 3) Compaction strategies and how to choose the right one 4) Important metrics which aren’t available in the default monitoring setup.
The Department of Veteran Affairs (VA) invited Taylor Paschal, Knowledge & Information Management Consultant at Enterprise Knowledge, to speak at a Knowledge Management Lunch and Learn hosted on June 12, 2024. All Office of Administration staff were invited to attend and received professional development credit for participating in the voluntary event.
The objectives of the Lunch and Learn presentation were to:
- Review what KM ‘is’ and ‘isn’t’
- Understand the value of KM and the benefits of engaging
- Define and reflect on your “what’s in it for me?”
- Share actionable ways you can participate in Knowledge - - Capture & Transfer
ScyllaDB is making a major architecture shift. We’re moving from vNode replication to tablets – fragments of tables that are distributed independently, enabling dynamic data distribution and extreme elasticity. In this keynote, ScyllaDB co-founder and CTO Avi Kivity explains the reason for this shift, provides a look at the implementation and roadmap, and shares how this shift benefits ScyllaDB users.
2. FABRIKAMFABRIKAM
About Me
• CTO at Labtek Indie
• Technically, generalist
• Host of Rabu Rust
• Current interest: Kubernetes,
Microservice, Serverless, PWA and
Street Fighter V
3. FABRIKAM
Microservice
• An architecture pattern that divides
monolithic application into several
different services
• Each service is responsible for a smaller
amount context
• Each one is independent and can be
invoked separately also, required to
communicate between services
• In practice, each service is deployed in
different server and has its own
database and communication interface
Quick In tro ductio n
This Photo by Unknown Author is licensed under CC BY-SA
4. FABRIKAM
Serverless Application
• A server logic part of the application,
deployed inside a fully managed server,
normally in cloud -> BaaS (Backend as a
Service)
• A server logic part of the application,
deployed as an independent function that
can live only as long as it is being invoked
-> FaaS (Function as a Service)
• In both cases, application can be scaled
automatically, according to usage
• This frees up developer to fully
concentrate on developing application,
and not managing server
Some alternative definitions
4
6. FABRIKAM
Serverless Solutions
• The aforementioned serverless solutions
are offered as a cloud-based
infrastructure offering
• Each has its own rule of what
environment they provide, what
languages they support and so forth
• Mostly accepted languages are:
• NodeJS
• Python
• Go
• PHP
Rule of the platform
6
9. FABRIKAM9
From Rust to Node in AWS Lambda
Function Handler
(NodeJS)
AWS API Gateway
Actual Function
(Rust)
• Implemented using Neon, a Rust crate that allows creation of
native Node modules from Rust code
• The Node code which implements the function handler, will call
this native module
• The Node code is called as usual JS script from the project root
(node .)
• Note that in order for Lambda function to work,it require a
function handler in Node
10. FABRIKAM10
From Rust to Node in AWS Lambda
// native/src/lib.rs
#[macro_use]
extern crate neon;
extern crate postgres;
use postgres::{Connection, TlsMode};
use neon::prelude::*;
fn hello(mut cx: FunctionContext) -> JsResult<JsString> {
Ok(cx.string("hello from Rust"))
}
register_module!(mut cx, {
cx.export_function("hello", hello)
});
// lib/index.js
const native = require('../native’);
exports.handler = (event, context, callback) =>
callback(null, native.hello());
11. FABRIKAM11
Deploy Rust Binary Inside Docker Container for Now Deployment
• Compile Rust into binary that fits Now’s requirement
• The easiest way is to build upon Now example and just deploy from that
• Deploy into Now network using the command now
• The serverless application will then live as an HTTP-based endpoint, ready to be used anytime
Rust binary Dockerized Now network
13. FABRIKAM
Reflection
Rust can be used to develop
serverless microservice with fast
response. However, it’s not yet
primed for production in leading
serverless platform. Docker-based
microservice is the most exciting
option for the time being
14. FABRIKAM
THANK YOU
A D I T YO P R ATO M O
+ 6 2 8 7 8 7 6 7 2 3 1 0 0
d i d i t @ l a b t e k i n d i e . c o m