A comprehensive walkthrough of how to manage infrastructure-as-code using Terraform. This presentation includes an introduction to Terraform, a discussion of how to manage Terraform state, how to use Terraform modules, an overview of best practices (e.g. isolation, versioning, loops, if-statements), and a list of gotchas to look out for.
For a written and more in-depth version of this presentation, check out the "Comprehensive Guide to Terraform" blog post series: https://blog.gruntwork.io/a-comprehensive-guide-to-terraform-b3d32832baca
This document discusses Terraform, an open-source tool that allows users to define and provision infrastructure resources in a declarative configuration file. It summarizes that Terraform allows users to build, change, and destroy infrastructure components like compute instances, storage buckets, and networking through declarative configuration files, enabling an infrastructure-as-code approach that is easy to version, track changes for, and integrate with continuous delivery practices.
Terraform is a tool for building, changing, and version controlling infrastructure safely and efficiently. It allows users to define and provision resources through code rather than manual configuration. Key concepts include variables, outputs, providers that interface with cloud platforms, reusable modules, and managing infrastructure through commands like plan, apply, and destroy. The presentation demonstrated Terraform's capabilities with a live demo and provided additional resources for learning more.
This document discusses Terraform, an open-source infrastructure as code tool. It begins by explaining how infrastructure can be defined and managed as code through services that have APIs. It then provides an overview of Terraform, including its core concepts of providers, resources, and data sources. The document demonstrates Terraform's declarative configuration syntax and process of planning and applying changes. It also covers features like modules, state management, data sources, and developing custom plugins.
This document introduces infrastructure as code (IaC) using Terraform and provides examples of deploying infrastructure on AWS including:
- A single EC2 instance
- A single web server
- A cluster of web servers using an Auto Scaling Group
- Adding a load balancer using an Elastic Load Balancer
It also discusses Terraform concepts and syntax like variables, resources, outputs, and interpolation. The target audience is people who deploy infrastructure on AWS or other clouds.
This document discusses infrastructure as code and the HashiCorp ecosystem. Infrastructure as code allows users to define and provision infrastructure through code rather than manual configuration. It can be used to launch, create, change, and downscale infrastructure based on configuration files. Tools like Terraform allow showing what changes will occur before applying them through files like main.tf and variables.tf. Terraform is part of the broader HashiCorp ecosystem of tools.
This document contains notes from a talk on advanced Terraform techniques. It discusses using Terraform for infrastructure as code to deploy resources across multiple environments like development, staging, and production. It also mentions techniques like separating code into modules, using variables to parameterize configurations, and integrating Terraform with other DevOps tools like Ansible.
Terraform modules and best-practices - September 2018Anton Babenko
Slides for my "Terraform modules and best-practices" talk on meetups during September 2018.
Some links from the slides:
https://www.terraform-best-practices.com/
https://cloudcraft.co/
https://github.com/terraform-aws-modules/
https://github.com/antonbabenko/modules.tf-lambda
This document summarizes a meetup about infrastructure as code. It discusses the differences between treating infrastructure as "pets" versus "cattle", where pets are cared for individually and cattle are treated as disposable. When infrastructure is coded declaratively using tools like Terraform, the infrastructure can be version controlled, updated continuously, and rolled back like code. The meetup demonstrated setting up infrastructure on Azure using Terraform to define resources like virtual machines in code. Advanced techniques like storing state remotely and using modules were also discussed.
This document discusses the infrastructure provisioning tool Terraform. It can be used to provision resources like EC2 instances, storage, and DNS entries across multiple cloud providers. Terraform uses configuration files to define what infrastructure should be created and maintains state files to track changes. It generates execution plans to determine what changes need to be made and allows applying those changes to create, update or destroy infrastructure.
Best Practices of Infrastructure as Code with TerraformDevOps.com
When your organization is moving to cloud, the infrastructure layer transitions from running dedicated servers at limited scale to a dynamic environment, where you can easily adjust to growing demand by spinning up thousands of servers and scaling them down when not in use.
The future of DevOps is infrastructure as code. Infrastructure as code supports the growth of infrastructure and provisioning requests. It treats infrastructure as software: code that can be re-used, tested, automated and version controlled. HashiCorp Terraform adopts infrastructure as code throughout its tool to prevent configuration drift, manage immutable infrastructure and much more!
Join this webinar to learn why Infrastructure as Code is the answer to managing large scale, distributed systems and service-oriented architectures. We will cover key use cases, a demo of how to use Infrastructure as Code to provision your infrastructure and more:
Agenda:
Intro to Infrastructure as Code: Challenges & Use cases
Writing Infrastructure as Code with Terraform
Collaborating with Teams on Infrastructure
This document provides an overview of Terraform including its key features and how to install, configure, and use Terraform to deploy infrastructure on AWS. It covers topics such as creating EC2 instances and other AWS resources with Terraform, using variables, outputs, and provisioners, implementing modules and workspaces, and managing the Terraform state.
While many organizations have started to automate their software develop processes, many still engineer their infrastructure largely by hand. Treating your infrastructure just like any other piece of code creates a “programmable infrastructure” that allows you to take full advantage of the scalability and reliability of the AWS cloud. This session will walk through practical examples of how AWS customers have merged infrastructure configuration with application code to create application-specific infrastructure and a truly unified development lifecycle. You will learn how AWS customers have leveraged tools like CloudFormation, orchestration engines, and source control systems to enable their applications to take full advantage of the scalability and reliability of the AWS cloud, create self-reliant applications, and easily recover when things go seriously wrong with their infrastructure.
Building infrastructure as code using Terraform - DevOps KrakowAnton Babenko
This document provides an overview of a DevOps meetup on building infrastructure as code using Terraform. The agenda includes Terraform basics, frequent questions, and problems. The presenter then discusses Terraform modules, tools, and solutions. He addresses common questions like secrets handling and integration with other tools. Finally, he solicits questions from the audience on Terraform use cases and challenges.
This document provides an introduction to Terraform and its key concepts. It describes Terraform as a tool for building, changing, and versioning infrastructure safely and efficiently using declarative configuration files. The document outlines some of Terraform's main components like providers, data sources, resources, variables and outputs. It also discusses the benefits of structuring Terraform configurations using modules to improve reusability and manageability.
Are you looking to automate your infrastructure but not sure where to start? View this presentation on ‘Getting started with Infrastructure as code’ to learn how to leverage IaC to deploy and manage resources on Azure. You will learn:
• Introduction to IaC
• Develop a simple IaC using Terraform
• Manage the deployed infrastructure using Terraform
View webinar recording at https://www.winwire.com/webinars
Terraform can be used to automate the deployment and management of infrastructure as code. It allows defining infrastructure components like VMs, networks, DNS records etc. as code in configuration files. Key benefits include versioning infrastructure changes, consistency across environments, and automation of deployments. The document then provides details on installing Terraform, using common commands like plan, apply and import, defining resources, variables, modules and managing remote state. It also demonstrates creating an EC2 instance using a generated AMI.
This document summarizes Anton Babenko's presentation on Terraform 0.12 and Terragrunt. Some key points include:
- Terraform 0.12 includes improvements like HCL2 syntax, loops and dynamic blocks that make configurations easier to write and maintain.
- Terragrunt is useful for orchestrating Terraform modules and enforcing best practices and standards.
- Modules.tf is a tool that can generate Terraform configurations from visual diagrams created in Cloudcraft, potentially providing ready-to-use infrastructure code.
This talk is a very quick intro to Docker, Terraform, and Amazon's EC2 Container Service (ECS). In just 15 minutes, you'll see how to take two apps (a Rails frontend and a Sinatra backend), package them as Docker containers, run them using Amazon ECS, and to define all of the infrastructure-as-code using Terraform.
This document discusses asynchronous I/O in Java and Scala using the Play Framework. It describes how LinkedIn uses a service-oriented architecture with hundreds of services making requests to each other. It then covers how Play supports non-blocking I/O using asynchronous code, promises, and futures to allow parallel requests without blocking threads. Key points covered include using map and flatMap to transform promises and futures, handling errors and timeouts, and the benefits of non-blocking I/O for scalability.
Listen up, developers. You are not special. Your infrastructure is not a beautiful and unique snowflake. You have the same tech debt as everyone else. This is a talk about a better way to build and manage infrastructure: Terraform Modules. It goes over how to build infrastructure as code, package that code into reusable modules, design clean and flexible APIs for those modules, write automated tests for the modules, and combine multiple modules into an end-to-end techs tack in minutes.
You can find the video here: https://www.youtube.com/watch?v=LVgP63BkhKQ
This document discusses rapid prototyping techniques for quickly building products from ideas. Rapid prototyping allows developers to build products faster through instant feedback on code changes and leveraging existing open source libraries. It is suggested that dynamic languages, interactive development environments, and pushing code to the browser can provide very fast feedback. While prototypes may be thrown away, the rapid trial and error process of prototyping can lead to higher quality products and better engineers through continuously improving ideas.
The document discusses LinkedIn's adoption of the Dust templating language in 2011. Some key points:
- LinkedIn needed a unified view layer as different teams were using different templating technologies like JSP, GSP, ERB.
- They evaluated 26 templating options and selected Dust as it best met their criteria like performance, i18n support, and being logic-less.
- Dust templates are compiled to JavaScript for client-side rendering and to Java for server-side rendering (SSR) through Google's V8 engine, allowing templates to work on both client and server.
- SSR addresses challenges like SEO, supporting clients without JavaScript, and i18n by rendering
This is the story of the Hackday and[in]cubator programs at LinkedIn; this is the story of scalable, best-of-breed methods for driving innovation; this is the story of transformation: of your career, company, and the world.
Video of the live presentation: http://tcbaltics.com/video/jim-brikman
Azure Infrastructure as Code and Hashicorp TerraformAlex Mags
This document discusses using Infrastructure as Code with Terraform and Azure. It begins with an introduction to Terraform and how it can be used to manage Azure infrastructure in a declarative way. The document then covers the Terraform workflow including editing configuration files, running a plan, and deploying infrastructure. It demonstrates Terraform through a live demo and discusses how it can benefit operations, security, and development teams. It concludes by discussing the partnership between Microsoft and HashiCorp to further integrate Terraform with Azure.
WinOps Conference London 2017 session
Public Cloud IaaS vs traditional on prem and how Hashicorp Terraform is a great tool to configure Azure. Recorded here: https://www.youtube.com/watch?v=LDZXRBBuXCU
Alex Magnay - Azure Infrastructure as Code with Hashicorp TerraformWinOps Conf
This document summarizes a presentation about using Terraform and Azure. The presentation introduces Infrastructure as Code and Terraform, shows how to manage Azure resources with Terraform, demonstrates the Terraform workflow, and discusses use cases for operations, security, and development teams. It also covers tips for using Terraform effectively and safely with Azure. Microsoft and Hashicorp have partnered to improve support for provisioning Azure services with Terraform.
Six Startup Lessons & The Essence of Venture CapitalAllan Martinson
This document provides 6 lessons for startups based on the author's experience. The 3 main points are:
1. Lesson 1 emphasizes that startups are about people, not just business ideas. It takes years of incubation and the right founding team with complementary skills and values to succeed.
2. Lesson 3 stresses the importance of pivoting if a startup fails to gain product/market fit or customer validation within set milestones. Slow failure is worse than failure.
3. Lesson 6 advises that raising venture capital requires understanding the venture capital process and life cycle of typical high-tech companies. It is important to pick smart investors who will provide long-term support.
To go faster in a car, you need not only a powerful engine, but also safety mechanisms like brakes, air bags, and seat belts. This is a talk about the safety mechanisms that allow you to build software faster. It's based on the book "Hello, Startup" (http://www.hello-startup.net/). You can find the video of the talk here: https://www.youtube.com/watch?v=4fKm6ImKml8
The Truth About Startups: What I wish someone had told me about entrepreneurs...Yevgeniy Brikman
This is the talk I gave at MIT's Martin Center for Entrepreneurship. It's a talk I wish someone gave me when I was in college to help me think about the role of entrepreneurship and startups in my career.
You can find the video of the talk here: https://www.youtube.com/watch?v=Rus32iR_Ag0
A brief overview of what we do at Gruntwork. Learn what we mean by "DevOps as a Service" and how you can get your entire infrastructure, defined as code, in about a day. https://www.gruntwork.io/
Practical workshop at UX London 2016, delivered by Doug Morwood of Business Models Inc UK. Great Value Proposition Design leads to great business success. Why? Because only by truly understanding the needs of the customer can we design solutions that last.
Business Model Innovation by Business Models Inc. Training SummaryBusiness Models Inc.
This document provides an overview of a training on business model innovation. It discusses how the world is changing and the need to design better business models. It introduces techniques for business model innovation such as applying business model patterns, looking at options to change various elements of the business model like customers or revenue streams, and using techniques like "what if" scenarios. The training emphasizes an iterative process of exploring options, testing assumptions, and getting feedback to design new business model prototypes.
Virtual Business Incubator Framework for Enriching Innovation Ecosystem 2013Vasily Ryzhonkov
The main purpose of this work is to find possible solutions for overcoming challenges of existing business incubation models. The end goal is to provide practitioners with the model of economic development tool which will help them to build new generation of business incubators, e.g. to guide management teams, policy makers, entrepreneurs and educators in establishing a successful business incubation program (BIP). Eventually the model intends to expand the limits of existing business incubation models.
Effective Marketing for the Public Practitioner - Presentation by Michael 'M...Practice Paradox
The document provides an overview of a marketing presentation for public practitioners given by Michael 'MC' Carter. Some key points:
1. The presentation covers why marketing has become a focus for many accounting firms, dispels common myths about marketing, and provides practical marketing tips.
2. A survey found the top challenges facing firms are growth, profitability, and cash flow. Many accountants have not received marketing or sales training.
3. The presentation defines an effective marketing machine and emphasizes measuring client relationships through the number of services provided per client. Niching and understanding social styles can help firms improve their marketing.
The document discusses the key components of a business model including users/customers, products/services, revenue flows, pricing, demand creation, and sales/distribution. It defines users as those who interact with the product for free, customers as those who pay for the product, and markets as customer segments. The business model canvas maps these components to understand what problem is being solved, who has this problem, how value is delivered and monetized, and how users and customers are acquired.
The document provides an overview of a workshop on business model design. It introduces business model canvas as a tool to visualize and design business models. Examples are used to illustrate how the canvas can be applied to understand Spotify's business model. Additional tools like vision canvas and context canvas are introduced. Tips are provided on how to use the business model canvas for redesign and innovation, including testing assumptions with customers and applying patterns from other business models.
My talk at FullStackFest, 4.9.2017. Become more familiar with managing infrastructure using Terraform, Packer and deployment pipeline. Code repository - https://github.com/antonbabenko/terraform-deployment-pipeline-talk
This document provides an overview of Terraform, an open-source infrastructure as code tool. It discusses Terraform's goals of providing a unified view of infrastructure, composing multiple tiers of infrastructure from IaaS to PaaS to SaaS, and safely changing infrastructure over time with one workflow. Key features highlighted include being open source, using infrastructure as code, resource providers that interface with cloud APIs, and the plan and apply workflow. The document also covers topics like collaboration and version history in Terraform Enterprise, file examples, the plan and apply commands, resource providers, and new features in recent Terraform versions like destroy provisioners, remote backends, state locking, and state environments.
Presentación empleada en el primer MeetUp AWS del grupo de usuarios de Valencia.
Infraestructura como código empleando Terraform. Se muestra las principales características de esta tecnología que nos permite ser más ágiles y rápidos desplegando nuestras plataformas en AWS.
Terraform modules provide reusable, composable infrastructure components. The document discusses restructuring infrastructure code into modules to make it more reusable, testable, and maintainable. Key points include:
- Modules should be structured in a three-tier hierarchy from primitive resources to generic services to specific environments.
- Testing modules individually increases confidence in changes.
- Storing module code and versions in Git provides versioning and collaboration.
- Remote state allows infrastructure to be shared between modules and deployments.
Infrastructure-as-Code (IaC) Using Terraform (Advanced Edition)Adin Ermie
In this new presentation, we will cover advanced Terraform topics (full-on DevOps). We will compare the deployment of Terraform using Azure DevOps, GitHub/GitHub Actions, and Terraform Cloud. We wrap everything up with some key takeaway learning resources in your Terraform learning adventure.
NOTE: A recording of this presenting is available here: https://www.youtube.com/watch?v=fJ8_ZbOIdto&t=5574s
Speaker: Jacob Aae Mikkelsen
Once you have successfully developped your application in Grails, Ratpack or your other favorite framework, you would like to see it deployed as fast and painless as possible, right?
This talk will cover some of the supporting cast members of a succesful modern infrastructure, that developers can understand and use efficiently, and with good DevOps practices.
Key elements are
Docker
Infrastructure as Code
Container Orchestration
The demo-goods will hopefully be on our side, as this talk includes quite some live demos!
How to test infrastructure code: automated testing for Terraform, Kubernetes,...Yevgeniy Brikman
This talk is a step-by-step, live-coding class on how to write automated tests for infrastructure code, including the code you write for use with tools such as Terraform, Kubernetes, Docker, and Packer. Topics covered include unit tests, integration tests, end-to-end tests, test parallelism, retries, error handling, static analysis, and more.
PuppetDB: Sneaking Clojure into Operationsgrim_radical
The document provides an overview of PuppetDB, which is a system for storing and querying data about infrastructure as code and system configurations. Some key points:
- PuppetDB stores immutable data about systems and allows querying of this data to enable higher-level infrastructure operations.
- It uses techniques like command query responsibility separation (CQRS) to separate write and read pipelines for better performance and reliability.
- The data is stored in a relational database for efficient querying, and queries are expressed in an abstract syntax tree (AST)-based language.
- The system is designed for speed, reliability, and ease of deployment in operations. It leverages techniques from Clojure and the JVM.
Infrastructure-as-Code (IaC) using TerraformAdin Ermie
Learn the benefits of Infrastructure-as-Code (IaC), what Terraform is and why people love it, along with a breakdown of the basics (including live demo deployments). Then wrap up with a comparison of Azure Resource Manager (ARM) templates versus Terraform, consider some best practices, and walk away with some key resources in your Terraform learning adventure.
This document contains biographical information about Boulos Dib, an independent consultant specializing in software development. It provides details about Dib's early experience with personal computers and programming languages. It also lists upcoming presentations by Dib on LightSwitch and Silverlight at the NYC Code Camp in October 2011. The document concludes with an overview of PowerShell scripting.
Declare your infrastructure: InfraKit, LinuxKit and MobyMoby Project
InfraKit is a toolkit for infrastructure orchestration. With an emphasis on immutable infrastructure, it breaks down infrastructure automation and management processes into small, pluggable components. These components work together to actively ensure the infrastructure state matches the user's specifications. InfraKit therefore provides infrastructure support for higher-level container orchestration systems and can make your infrastructure self-managing and self-healing.
https://www.youtube.com/watch?v=IeweKUdHJc4
My presentation from Hashiconf 2017, discussing our use of Terraform, and our techniques
to help make it safe and accessible.
Using Terraform to manage the configuration of a Cisco ACI fabric.Joel W. King
Terraform is an open-source infrastructure as code software tool created by HashiCorp. It is written in GoLang. Cisco has developed an ACI terraform provider used to interact with the Cisco APIC. Network engineers define and provision the ACI infrastructure using a declarative configuration language known as HCL, HashiCorp Configuration Language.
This session will begin with a short presentation on Terraform and how it can be used to manage resources in an ACI fabric. There is a companion GitLab repository (https://gitlab.com/joelwking/terraform_aci) which will be used as a demo environment. Attendees can download Vagrant and VirtualBox to their laptop and execute the demonstration using the Cisco DevNet Always-on ACI sandbox.
Immutable Deployments with AWS CloudFormation and AWS LambdaAOE
This document describes an immutable infrastructure approach using AWS Lambda and CloudFormation. Key points:
- Infrastructure is defined as code using CloudFormation templates for reproducibility and versioning.
- Lambda functions are used to provision resources, configure settings, run tests, and clean up resources to enforce immutability.
- A pipeline handles building AMIs, deploying stacks, testing, updating DNS, and deleting old stacks in an automated and repeatable way.
Aprovisionamiento multi-proveedor con Terraform - Plain Concepts DevOps dayPlain Concepts
La infraestructura como código (IaC) es una de las prácticas relacionadas con la cultura DevOps que está cogiendo más tracción en el desarrollo de software y Terraform es una de las herramientas más recomendadas para ello.
Se suele relacionar sobre todo con la creación de infraestructura en los grandes servicios “Cloud” -AWS, Azure, Google Cloud,…- pero es además algo aplicable a otros aspectos de IT como podrían ser la creación de usuarios en servicios de terceros o propios (Github, bases de datos,…), configuración de dominios (Dyn, GoDaddy,…), configuración de alertas (Grafana, OpsGenie)…
Durante esta sesión se explicará su funcionamiento básico y veremos en directo despliegues en varias de estas plataformas.
Jan Stępień - GraalVM: Fast, Polyglot, Native - Codemotion Berlin 2018Codemotion
GraalVM challenges the status quo on the JVM. This newly-released JIT compiler brings substantial speed improvements and support for polyglot applications. It also allows us to translate our JVM bytecode into self-contained native binaries. In this session we’ll explore GraalVM’s potential. We’ll focus on Clojure, but our discussion will apply to many more programming languages. We’ll use GraalVM to build small native binaries. We’ll discuss the method’s limitations and their impact. Finally, we’ll build complete Clojure web apps weighing a fraction of their traditional JVM incarnations.
LAMP Stack (Reloaded) - Infrastructure as Code with Terraform & PackerJan-Christoph Küster
Talk given at Coding Leipzig Meetup (8th August, 2018).
Why infrastructure should be managed as code (IaC), a small intro to the IaC-tooling Terraform (and Packer), and a demo that shows how to use Terraform to deploy a good old LAMP Stack into the Cloud by the push of a button (https://github.com/cloudetc/lamp-stack-for-aws).
Cloud adoption fails - 5 ways deployments go wrong and 5 solutionsYevgeniy Brikman
"All happy cloud deployments are alike; each unhappy cloud deployment is unhappy in its own way." — Leo Tolstoy, Site Reliability Engineer
At Gruntwork, I've had the chance to see the cloud adoption journeys of hundreds of companies, from tiny startups to Fortune 50 giants. I've seen those journeys go well. I've seen those journeys go poorly. In this talk, I discuss a few of the ways cloud adoption can go horribly wrong (massive cost overruns, endless death marches, security disasters), and more importantly, how you can get it right.
To help you get it right, we looked at the cloud journeys that were successful and extracted from them the patterns they had in common. We distilled all this experience down into something called the Gruntwork Production Framework, which defines five concrete steps you can follow to adopt the cloud at your own company—and hopefully, to end up with your very own happy cloud deployment.
Lessons learned from writing over 300,000 lines of infrastructure codeYevgeniy Brikman
This talk is a concise masterclass on how to write infrastructure code. I share key lessons from the “Infrastructure Cookbook” we developed at Gruntwork while creating and maintaining a library of over 300,000 lines of infrastructure code that’s used in production by hundreds of companies. Come and hear our war stories, laugh about all the mistakes we’ve made along the way, and learn what Terraform, Packer, Docker, and Go look like in the wild.
Infrastructure as code: running microservices on AWS using Docker, Terraform,...Yevgeniy Brikman
This is a talk about managing your software and infrastructure-as-code that walks through a real-world example of deploying microservices on AWS using Docker, Terraform, and ECS.
Every startup begins with an idea. This is a talk on how to come up with startup ideas and how to use validation to pick the ones worth working on. It's based on the book "Hello, Startup" (http://www.hello-startup.net/). You can find the video of the talk here: https://www.youtube.com/watch?v=GkmiE8d_5Pw
A guide to hiring based on my book, "Hello, Startup". Learn who to hire, where to find them, how to interview them, and how to make an offer they can't refuse.
Recording: https://www.youtube.com/watch?v=jaSmYLymc0U
Book: http://www.hello-startup.net
This is an excerpt from my talk "Startup DNA" (http://www.slideshare.net/brikis98/startup-dna) that just focuses on the "Speed Wins" concept. For more info, check out my book "Hello, Startup: A Programmer's Guide to Building Products, Technologies, and Teams" at http://www.hello-startup.net.
Node.js vs Play Framework (with Japanese subtitles)Yevgeniy Brikman
Video: http://www.nicovideo.jp/watch/1410857293
Here's the showdown you've been waiting for: Node.js vs Play Framework. Both are popular open source web frameworks that are built for developer productivity, asynchronous I/O, and the real time web. But which one is easier to learn, test, deploy, debug, and scale? Should you pick Javascript or Scala? The Google v8 engine or the JVM? NPM or Ivy? Grunt or SBT? Two frameworks enter, one framework leaves.
This version of the presentation has Japanese subtitles. For the English only version, see http://www.slideshare.net/brikis98/nodejs-vs-play-framework
Video: https://www.youtube.com/watch?v=b6yLwvNSDck
Here's the showdown you've been waiting for: Node.js vs Play Framework. Both are popular open source web frameworks that are built for developer productivity, asynchronous I/O, and the real time web. But which one is easier to learn, test, deploy, debug, and scale? Should you pick Javascript or Scala? The Google v8 engine or the JVM? NPM or Ivy? Grunt or SBT? Two frameworks enter, one framework leaves.
This is the English version of the presentation. For the version with Japanese subtitles, see http://www.slideshare.net/brikis98/nodejs-vs-play-framework-with-japanese-subtitles
Web pages can get very complex and slow. In this talk, I share how we solve some of these problems at LinkedIn by leveraging composition and streaming in the Play Framework. This was my keynote for Ping Conference 2014 ( http://www.ping-conf.com/ ): the video is on ustream ( http://www.ustream.tv/recorded/42801129 ) and the sample code is on github ( https://github.com/brikis98/ping-play ).
Video of the presentation: http://www.youtube.com/watch?v=8z3h4Uv9YbE
At LinkedIn, we have started to use the Play Framework to build front-end and back-end services at massive scale. Play does things a little differently: it's a Java and Scala web framework, but it doesn't follow the servlet spec; it's fairly new, but it runs on top of robust technologies like Akka and Netty; it uses a thread pool, but it's built for non-blocking I/O and reactive programming; most importantly, it's high performance, but also high productivity. We've found that the Play Framework is one of the few frameworks that is able to maintain the delicate balance of performance, reliability, and developer productivity. In the Java and Scala world, nothing even comes close. In this talk, I'll share what we've learned so far, including details of rapid iteration with Java and Scala, the story behind async I/O on the JVM, support for real time web apps (comet, WebSockets), and integrating Play into a large existing codebase.
Startup DNA: the formula behind successful startups in Silicon Valley (update...Yevgeniy Brikman
[Updated May 5, 2017] "Successful startups are all alike; every unsuccessful startup is unsuccessful in its own way." These are my personal observations on a few traits that make startups successful. You can find a video of the talk at https://www.youtube.com/watch?v=z_D9oXCK2lM and the book at http://www.hello-startup.net/.
COVID-19 and the Level of Cloud Computing Adoption: A Study of Sri Lankan Inf...AimanAthambawa1
The study’s main objective is to analyse the level of cloud computing adoption and usage during COVID-19 in Sri
Lanka, especially in Information Technology (IT) organisations. Using senior IT employees, this study investigates
what extent their organisation adopts with cloud computing, the level of cloud computing usage, current use of
cloud service model, usage of cloud deployment model, preferred cloud service providers and reasons for adopting
and not adopting cloud computing. The study also describes why cloud computing is a solution for new normal
situations and the cloud-enabled services used during and after the COVID-19 pandemic. The finding suggests
that 87.7% of the organisations currently use cloud-enabled services, whereas 12.3% do not and intend to adopt.
Considering the benefits, cloud computing is the solution post COVID-19 pandemic to run the business way
forward.
How UiPath Discovery Suite supports identification of Agentic Process Automat...DianaGray10
📚 Understand the basics of the newly persona-based LLM-powered Agentic Process Automation and discover how existing UiPath Discovery Suite products like Communication Mining, Process Mining, and Task Mining can be leveraged to identify APA candidates.
Topics Covered:
💡 Idea Behind APA: Explore the innovative concept of Agentic Process Automation and its significance in modern workflows.
🔄 How APA is Different from RPA: Learn the key differences between Agentic Process Automation and Robotic Process Automation.
🚀 Discover the Advantages of APA: Uncover the unique benefits of implementing APA in your organization.
🔍 Identifying APA Candidates with UiPath Discovery Products: See how UiPath's Communication Mining, Process Mining, and Task Mining tools can help pinpoint potential APA candidates.
🔮 Discussion on Expected Future Impacts: Engage in a discussion on the potential future impacts of APA on various industries and business processes.
Enhance your knowledge on the forefront of automation technology and stay ahead with Agentic Process Automation. 🧠💼✨
Speakers:
Arun Kumar Asokan, Delivery Director (US) @ qBotica and UiPath MVP
Naveen Chatlapalli, Solution Architect @ Ashling Partners and UiPath MVP
MAKE MONEY ONLINE Unlock Your Income Potential Today.pptxjanagijoythi
In today's digital age, the internet offers unparalleled opportunities to
generate income and build financial independence from the comfort of
your home or anywhere with an internet connection. Whether you're a
student looking to earn extra cash, a stay-at-home parent seeking
flexible work options, or a professional aiming to diversify your income
streams, this book is your comprehensive guide to navigating the vast
landscape of online earning.
kk vathada _digital transformation frameworks_2024.pdfKIRAN KV
I'm excited to share my latest presentation on digital transformation frameworks from industry leaders like PwC, Cognizant, Gartner, McKinsey, Capgemini, MIT, and DXO. These frameworks are crucial for driving innovation and success in today's digital age. Whether you're a consultant, director, or head of digital transformation, these insights are tailored to help you lead your organization to new heights.
🔍 Featured Frameworks:
PwC's Framework: Grounded in Industry 4.0 with a focus on data and analytics, and digitizing product and service offerings.
Cognizant's Framework: Enhancing customer experience, incorporating new pricing models, and leveraging customer insights.
Gartner's Framework: Emphasizing shared understanding, leadership, and support teams for digital excellence.
McKinsey's 4D Framework: Discover, Design, Deliver, and De-risk to navigate digital change effectively.
Capgemini's Framework: Focus on customer experience, operational excellence, and business model innovation.
MIT’s Framework: Customer experience, operational processes, business models, digital capabilities, and leadership culture.
DXO's Framework: Business model innovation, digital customer experience, and digital organization & process transformation.
Types of Weaving loom machine & it's technologyldtexsolbl
Welcome to the presentation on the types of weaving loom machines, brought to you by LD Texsol, a leading manufacturer of electronic Jacquard machines. Weaving looms are pivotal in textile production, enabling the interlacing of warp and weft threads to create diverse fabrics. Our exploration begins with traditional handlooms, which have been in use since ancient times, preserving artisanal craftsmanship. We then move to frame and pit looms, simple yet effective tools for small-scale and traditional weaving.
Advancing to modern industrial applications, we discuss power looms, the backbone of high-speed textile manufacturing. These looms, integral to LD Texsol's product range, offer unmatched productivity and consistent quality, essential for large-scale apparel, home textiles, and technical fabrics. Rapier looms, another modern marvel, use rapier rods for versatile and rapid weaving of complex patterns.
Next, we explore air and water jet looms, known for their efficiency in lightweight fabric production. LD Texsol's state-of-the-art electronic Jacquard machines exemplify technological advancements, enabling intricate designs and patterns with precision control. Lastly, we examine dobby looms, ideal for medium-complexity patterns and versatile fabric production.
This presentation will deepen your understanding of weaving looms, their applications, and the innovations LD Texsol brings to the textile industry. Join us as we weave through the history, technology, and future of textile production. Visit our website www.ldtexsol.com for more information.
EuroPython 2024 - Streamlining Testing in a Large Python CodebaseJimmy Lai
Maintaining code quality through effective testing becomes increasingly challenging as codebases expand and developer teams grow. In our rapidly expanding codebase, we encountered common obstacles such as increasing test suite execution time, slow test coverage reporting and delayed test startup. By leveraging innovative strategies using open-source tools, we achieved remarkable enhancements in testing efficiency and code quality.
As a result, in the past year, our test case volume increased by 8000, test coverage was elevated to 85%, and Continuous Integration (CI) test duration was maintained under 15 minute
The History of Embeddings & Multimodal EmbeddingsZilliz
Frank Liu will walk through the history of embeddings and how we got to the cool embedding models used today. He'll end with a demo on how multimodal RAG is used.
Integrating Kafka with MuleSoft 4 and usecaseshyamraj55
In this slides, the speaker shares their experiences in the IT industry, focusing on the integration of Apache Kafka with MuleSoft. They start by providing an overview of Kafka, detailing its pub-sub model, its ability to handle large volumes of data, and its role in real-time data pipelines and analytics. The speaker then explains Kafka's architecture, covering topics such as partitions, producers, consumers, brokers, and replication.
The discussion moves on to Kafka connector operations within MuleSoft, including publish, consume, commit, and seek, which are demonstrated in a practical demo. The speaker also emphasizes important design considerations like connector configuration, flow design, topic management, consumer group management, offset management, and logging. The session wraps up with a Q&A segment where various Kafka-related queries are addressed.
Improving Learning Content Efficiency with Reusable Learning ContentEnterprise Knowledge
Enterprise Knowledge’s Emily Crockett, Content Engineering Consultant, presented “Improve Learning Content Efficiency with Reusable Learning Content” at the Learning Ideas conference on June 13th, 2024.
This presentation explored the basics of reusable learning content, including the types of reuse and the key benefits of reuse such as improved content maintenance efficiency, reduced organizational risk, and scalable differentiated instruction & personalization. After this primer on reuse, Crockett laid out the basic steps to start building reusable learning content alongside a real-life example and the technology stack needed to support dynamic content. Key objectives included:
- Be able to explain the difference between reusable learning content and duplicate content
- Explore how a well-designed learning content model can reduce duplicate content and improve your team’s efficiency
- Identify key tasks and steps in creating a learning content model
Keynote : AI & Future Of Offensive SecurityPriyanka Aash
In the presentation, the focus is on the transformative impact of artificial intelligence (AI) in cybersecurity, particularly in the context of malware generation and adversarial attacks. AI promises to revolutionize the field by enabling scalable solutions to historically challenging problems such as continuous threat simulation, autonomous attack path generation, and the creation of sophisticated attack payloads. The discussions underscore how AI-powered tools like AI-based penetration testing can outpace traditional methods, enhancing security posture by efficiently identifying and mitigating vulnerabilities across complex attack surfaces. The use of AI in red teaming further amplifies these capabilities, allowing organizations to validate security controls effectively against diverse adversarial scenarios. These advancements not only streamline testing processes but also bolster defense strategies, ensuring readiness against evolving cyber threats.
Connector Corner: Leveraging Snowflake Integration for Smarter Decision MakingDianaGray10
The power of Snowflake analytics enables CRM systems to improve operational efficiency, while gaining deeper insights into closed/won opportunities.
In this webinar, learn how infusing Snowflake into your CRM can quickly provide analysis for sales wins by region, product, customer segmentation, customer lifecycle—and more!
Using prebuilt connectors, we’ll show how workflows using Snowflake, Salesforce, and Zendesk tickets can significantly impact future sales.
Finetuning GenAI For Hacking and DefendingPriyanka Aash
Generative AI, particularly through the lens of large language models (LLMs), represents a transformative leap in artificial intelligence. With advancements that have fundamentally altered our approach to AI, understanding and leveraging these technologies is crucial for innovators and practitioners alike. This comprehensive exploration delves into the intricacies of GenAI, from its foundational principles and historical evolution to its practical applications in security and beyond.
It's your unstructured data: How to get your GenAI app to production (and spe...Zilliz
So you've successfully built a GenAI app POC for your company -- now comes the hard part: bringing it to production. Aparavi addresses the challenges of AI projects while addressing data privacy and PII. Our Service for RAG helps AI developers and data scientists to scale their app to 1000s to millions of users using corporate unstructured data. Aparavi’s AI Data Loader cleans, prepares and then loads only the relevant unstructured data for each AI project/app, enabling you to operationalize the creation of GenAI apps easily and accurately while giving you the time to focus on what you really want to do - building a great AI application with useful and relevant context. All within your environment and never having to share private corporate data with anyone - not even Aparavi.
Intel Unveils Core Ultra 200V Lunar chip .pdfTech Guru
Intel has made a significant breakthrough in the world of processors with the introduction of its Core Ultra 200V mobile processor series, codenamed Lunar Lake. This innovative processor marks a fundamental shift in the way Intel creates processors, with a high degree of aggregation, including memory-on-package (MoP). The Core Ultra 300 MX series is designed to power thin-and-light devices that are capable of handling the latest AI applications, including Microsoft's Copilot+ experiences.
2. We’ve pre-written Terraform
packages for the most common
AWS components.
We test, update, and support
these packages.
When a software team
purchases a package, they get
100% of the source code.
http://gruntwork.io
Gruntwork
11. provider "aws" {
region = "us-east-1"
}
resource "aws_instance" "example" {
ami = "ami-408c7f28"
instance_type = "t2.micro"
tags { Name = "terraform-example" }
}
This template creates a single EC2
instance in AWS
12. > terraform plan
+ aws_instance.example
ami: "" => "ami-408c7f28"
instance_type: "" => "t2.micro"
key_name: "" => "<computed>"
private_ip: "" => "<computed>"
public_ip: "" => "<computed>"
Plan: 1 to add, 0 to change, 0 to destroy.
Use the plan command to see
what you’re about to deploy
16. variable "name" {
description = "The name of the EC2 instance"
}
Define a variable. description,
default, and type are optional.
17. resource "aws_instance" "example" {
ami = "ami-408c7f28"
instance_type = "t2.micro"
tags { Name = "${var.name}" }
}
Note the use of ${} syntax to
reference var.name in tags
variable "name" {
description = "The name of the EC2 instance"
}
18. > terraform plan
var.name
Enter a value: foo
~ aws_instance.example
tags.Name: "terraform-example" => "foo"
Use plan to verify your changes. It
prompts you for the variable.
19. > terraform apply -var name=foo
aws_instance.example: Refreshing state...
aws_instance.example: Modifying...
tags.Name: "terraform-example" => "foo"
aws_instance.example: Modifications complete
Apply complete! Resources: 0 added, 1 changed, 0 destroyed.
You can also pass variables using
the -var parameter
21. resource "aws_eip" "example" {
instance = "${aws_instance.example.id}”
}
Notice the use of ${} to depend on
the id of the aws_instance
resource "aws_instance" "example" {
ami = "ami-408c7f28"
instance_type = "t2.micro"
tags { Name = "${var.name}" }
}
28. > ls -al
-rw-r--r-- 6024 Apr 5 17:58 terraform.tfstate
-rw-r--r-- 6024 Apr 5 17:58 terraform.tfstate.backup
By default, state is stored locally
in .tfstate files
29. > terraform remote config
-backend=s3
-backend-config=bucket=my-s3-bucket
-backend-config=key=terraform.tfstate
-backend-config=encrypt=true
-backend-config=region=us-east-1
You can enable remote state
storage in S3, Atlas, Consul, etc.
46. variable "name" {
description = "The name of the EC2 instance"
}
variable "ami" {
description = "The AMI to run on the EC2 instance"
}
variable "port" {
description = "The port to listen on for HTTP requests"
}
Specify module inputs in vars.tf
47. resource "aws_instance" "example" {
ami = "${var.ami}"
instance_type = "t2.micro"
user_data = "${template_file.user_data.rendered}"
tags { Name = "${var.name}" }
}
Create resources in main.tf
48. output "url" {
value = "http://${aws_instance.example.ip}:${var.port}"
}
Specify outputs in outputs.tf
53. module "example_rails_app" {
source = "git::git@github.com:foo/bar.git//module?ref=0.1"
name = "Example Rails App"
ami = "ami-123asd1"
port = 8080
}
Specify the module’s inputs like
any other Terraform resource
54. module "example_rails_app_stg" {
source = "./rails-module"
name = "Example Rails App staging"
}
module "example_rails_app_prod" {
source = "./rails-module"
name = "Example Rails App production"
}
You can reuse the same module
multiple times
55. > terraform get -update
Get: file:///home/ubuntu/modules/rails-module
Get: file:///home/ubuntu/modules/rails-module
Get: file:///home/ubuntu/modules/asg-module
Get: file:///home/ubuntu/modules/vpc-module
Run the get command before
running plan or apply
65. global (Global resources such as IAM, SNS, S3)
└ main.tf
└ .terragrunt
stage (Non-production workloads, testing)
└ main.tf
└ .terragrunt
prod (Production workloads, user-facing apps)
└ main.tf
└ .terragrunt
mgmt (DevOps tooling such as Jenkins, Bastion Host)
└ main.tf
└ .terragrunt
66. global (Global resources such as IAM, SNS, S3)
└ main.tf
└ .terragrunt
stage (Non-production workloads, testing)
└ main.tf
└ .terragrunt
prod (Production workloads, user-facing apps)
└ main.tf
└ .terragrunt
mgmt (DevOps tooling such as Jenkins, Bastion Host)
└ main.tf
└ .terragruntEach folder gets its own .tfstate
67. global (Global resources such as IAM, SNS, S3)
└ main.tf
└ .terragrunt
stage (Non-production workloads, testing)
└ main.tf
└ .terragrunt
prod (Production workloads, user-facing apps)
└ main.tf
└ .terragrunt
mgmt (DevOps tooling such as Jenkins, Bastion Host)
└ main.tf
└ .terragrunt
Use terraform_remote_state to share
state between them
74. global (Global resources such as IAM, SNS, S3)
└ iam
└ sns
stage (Non-production workloads, testing)
└ vpc
└ mysql
└ frontend
prod (Production workloads, user-facing apps)
└ vpc
└ mysql
└ frontend
mgmt (DevOps tooling such as Jenkins, Bastion Host)
└ vpc
└ bastion
75. global (Global resources such as IAM, SNS, S3)
└ iam
└ sns
stage (Non-production workloads, testing)
└ vpc
└ mysql
└ frontend
prod (Production workloads, user-facing apps)
└ vpc
└ mysql
└ frontend
mgmt (DevOps tooling such as Jenkins, Bastion Host)
└ vpc
└ bastion
Each component in each environment
gets its own .tfstate
76. global (Global resources such as IAM, SNS, S3)
└ iam
└ sns
stage (Non-production workloads, testing)
└ vpc
└ mysql
└ frontend
prod (Production workloads, user-facing apps)
└ vpc
└ mysql
└ frontend
mgmt (DevOps tooling such as Jenkins, Bastion Host)
└ vpc
└ bastion
Use terraform_remote_state to share
state between them
78. stage
└ vpc
└ mysql
└ frontend
prod
└ vpc
└ mysql
└ frontend
How do you avoid copy/pasting code
between stage and prod?
79. stage
└ vpc
└ mysql
└ frontend
prod
└ vpc
└ mysql
└ frontend
modules
└ vpc
└ mysql
└ frontend
Define reusable modules!
80. stage
└ vpc
└ mysql
└ frontend
prod
└ vpc
└ mysql
└ frontend
modules
└ vpc
└ mysql
└ frontend
└ main.tf
└ outputs.tf
└ vars.tf
Each module defines one reusable
component
81. variable "name" {
description = "The name of the EC2 instance"
}
variable "ami" {
description = "The AMI to run on the EC2 instance"
}
variable "memory" {
description = "The amount of memory to allocate"
}
Define inputs in vars.tf to
configure the module
82. module "frontend" {
source = "./modules/frontend"
name = "frontend-stage"
ami = "ami-123asd1"
memory = 512
}
Use the module in stage
(stage/frontend/main.tf)
83. module "frontend" {
source = "./modules/frontend"
name = "frontend-prod"
ami = "ami-123abcd"
memory = 2048
}
And in prod
(prod/frontend/main.tf)
85. stage
└ vpc
└ mysql
└ frontend
prod
└ vpc
└ mysql
└ frontend
modules
└ vpc
└ mysql
└ frontend
If stage and prod point to the
same folder, you lose isolation
86. stage
└ vpc
└ mysql
└ frontend
prod
└ vpc
└ mysql
└ frontend
modules
└ vpc
└ mysql
└ frontend
Any change in modules/frontend
affects both stage and prod
87. infrastructure-live
└ stage
└ vpc
└ mysql
└ frontend
└ prod
└ vpc
└ mysql
└ frontend
infrastructure-modules
└ vpc
└ mysql
└ frontend
Solution: define modules in a
separate repository
88. infrastructure-live
└ stage
└ vpc
└ mysql
└ frontend
└ prod
└ vpc
└ mysql
└ frontend
infrastructure-modules
└ vpc
└ mysql
└ frontend
Now stage and prod can use
different versioned URLs
0.1
0.2
89. module "frontend" {
source =
"git::git@github.com:foo/infrastructure-
modules.git//frontend?ref=0.2"
name = "frontend-prod"
ami = "ami-123abcd"
memory = 2048
}
Example Terraform code
(prod/frontend/main.tf)
101. resource "aws_instance" "example" {
count = 3
ami = "${var.ami}"
instance_type = "t2.micro"
tags { Name = "${var.name}-${count.index}" }
}
Create three EC2 Instances, each
with a different name
102. Do even more with interpolation
functions:
terraform.io/docs/configuration/interpolation.html
103. resource "aws_instance" "example" {
count = 3
ami = "${element(var.amis, count.index)}"
instance_type = "t2.micro"
tags { Name = "${var.name}-${count.index}" }
}
variable "amis" {
type = "list"
default = ["ami-abc123", "ami-abc456", "ami-abc789"]
}
Create three EC2 Instances, each
with a different AMI
104. output "all_instance_ids" {
value = ["${aws_instance.example.*.id}"]
}
output "first_instance_id" {
value = "${aws_instance.example.0.id}"
}
Note: resources with count are
actually lists of resources!
107. But you can do a limited form of
if-statement using count
108. resource "aws_instance" "example" {
count = "${var.should_create_instance}"
ami = "ami-abcd1234"
instance_type = "t2.micro"
tags { Name = "${var.name}" }
}
variable "should_create_instance" {
default = true
}
Note the use of a boolean in the
count parameter
116. Valid plan to create IAM instance
profiles
> terraform plan
+ aws_iam_instance_profile.instance_profile
arn: "<computed>"
create_date: "<computed>"
name: "stage-iam-nat-role"
path: "/"
roles.2760019627: "stage-iam-nat-role"
unique_id: "<computed>”
Plan: 1 to add, 0 to change, 0 to destroy.
118. You get an error
> terraform apply
Error applying plan:
* Error creating IAM role stage-iam-nat-role:
EntityAlreadyExists: Role with name stage-iam-nat-role already
exists
status code: 409, requestId: [e6812c4c-6fac-495c-be9d]
123. > terraform apply
...
* aws_route.internet-gateway:
error finding matching route for Route table (rtb-5ca64f3b)
and destination CIDR block (0.0.0.0/0)
124. > terraform apply
...
* Resource 'aws_eip.nat' does not have attribute 'id' for
variable 'aws_eip.nat.id'
125. > terraform apply
...
* aws_subnet.private-persistence.2: InvalidSubnetID.NotFound:
The subnet ID 'subnet-xxxxxxx' does not exist
126. > terraform apply
...
* aws_route_table.private-persistence.2:
InvalidRouteTableID.NotFound: The routeTable ID 'rtb-2d0d2f4a'
does not exist
127. > terraform apply
...
* aws_iam_instance_profile.instance_profile: diffs didn't
match during apply. This is a bug with Terraform and should be
reported.
* aws_security_group.asg_security_group_stg: diffs didn't
match during apply. This is a bug with Terraform and should be
reported.
The most generic one: diffs didn’t
match during apply
128. Most of these are harmless. Just
re-run terraform apply.
129. And try to run Terraform close to
your AWS region (replica lag)
146. Advantages of Terraform:
1. Define infrastructure-as-code
2. Concise, readable syntax
3. Reuse: inputs, outputs, modules
4. Plan command!
5. Cloud agnostic
6. Very active development
147. Disadvantages of Terraform:
1. Maturity. You will hit bugs.
2. Collaboration on Terraform state is
tricky (but not with terragrunt)
3. No rollback
4. Poor secrets management
148. Questions?
Want to know when we share additional DevOps training?
Sign up for our Newsletter.
gruntwork.io/newsletter