Muutke küpsiste eelistusi

E-raamat: Deploying with JRuby 9k: Deliver Scalable Web Apps Using the JVM

  • Formaat: 180 pages
  • Ilmumisaeg: 19-Jul-2016
  • Kirjastus: Pragmatic Bookshelf
  • Keel: eng
  • ISBN-13: 9781680503425
Teised raamatud teemal:
  • Formaat - EPUB+DRM
  • Hind: 21,64 €*
  • * hind on lõplik, st. muud allahindlused enam ei rakendu
  • Lisa ostukorvi
  • Lisa soovinimekirja
  • See e-raamat on mõeldud ainult isiklikuks kasutamiseks. E-raamatuid ei saa tagastada.
  • Formaat: 180 pages
  • Ilmumisaeg: 19-Jul-2016
  • Kirjastus: Pragmatic Bookshelf
  • Keel: eng
  • ISBN-13: 9781680503425
Teised raamatud teemal:

DRM piirangud

  • Kopeerimine (copy/paste):

    ei ole lubatud

  • Printimine:

    ei ole lubatud

  • Kasutamine:

    Digitaalõiguste kaitse (DRM)
    Kirjastus on väljastanud selle e-raamatu krüpteeritud kujul, mis tähendab, et selle lugemiseks peate installeerima spetsiaalse tarkvara. Samuti peate looma endale  Adobe ID Rohkem infot siin. E-raamatut saab lugeda 1 kasutaja ning alla laadida kuni 6'de seadmesse (kõik autoriseeritud sama Adobe ID-ga).

    Vajalik tarkvara
    Mobiilsetes seadmetes (telefon või tahvelarvuti) lugemiseks peate installeerima selle tasuta rakenduse: PocketBook Reader (iOS / Android)

    PC või Mac seadmes lugemiseks peate installima Adobe Digital Editionsi (Seeon tasuta rakendus spetsiaalselt e-raamatute lugemiseks. Seda ei tohi segamini ajada Adober Reader'iga, mis tõenäoliselt on juba teie arvutisse installeeritud )

    Seda e-raamatut ei saa lugeda Amazon Kindle's. 

Deploy using the JVM's high performance while building your apps in the language you love. This book introduces you to three JRuby deployment strategies that give you the performance and scalability you need, while you use a language designed for rapid development. Explore common deployment scenarios, including consolidating an MRI-based Ruby deployment onto a single JVM process and porting a Rails application to JRuby, getting it into production, and keeping it running. This new edition has new chapters on Puma, performance tuning, and Java integration, and is updated to the latest versions of JRuby 9k, Rails 4, and JDK 8.

JRuby is a fast, scalable, and powerful JVM language with all the benefits of a traditional Ruby environment. JRuby deployments have fewer moving parts and consume less memory than traditional Ruby. With this book, you can now use JRuby in the real world to build high-performance, scalable applications.

Deploying your apps on the JVM requires some new approaches. Start by creating a JRuby microservice that takes advantage of the JVM's native concurrency. Then use Docker to build a virtual production environment that's a stable, reproducible place to explore JRuby deployment. Next, port an existing Rails application to JRuby, preparing the app to take advantage of the JVM platform--all while keeping everything that's friendly and familiar to Ruby developers. Deploy the Rails app to Docker with a multi-threaded Puma server to Heroku or your own private cloud.

Take advantage of powerful Java libraries. See how JRuby fits into the enterprise by switching your app to use TorqueBox, an all-in-one JRuby environment that includes built-in support for messaging, scheduling, and daemons--perfect for handling the big jobs. Finally, take a deep dive into JVM performance tuning and set up a continuous deployment environment with Travis CI.

What You Need:

To run the examples in this book, you'll need a computer that can run the Java Virtual Machine and a connection to the Internet.

Acknowledgments ix
Preface xi
1 Getting Started with JRuby
1(16)
What Makes JRuby So Great?
2(2)
Preparing Your Environment
4(3)
Introducing Warbler
7(3)
Creating a JRuby Microservice
10(5)
Wrapping Up
15(2)
2 Creating a Deployment Environment
17(12)
Installing Docker
17(3)
Getting Started with Docker
20(2)
Creating a Docker Image
22(2)
Deploying to the Cloud
24(3)
Wrapping Up
27(2)
3 Deploying a Rails Application
29(20)
What Is Traditional Deployment?
29(1)
Porting to JRuby
30(4)
Configuring Rails for Production
34(2)
Creating the Deployment Environment
36(4)
Deploying to the Public Cloud
40(1)
Deploying to Private Infrastructure
41(7)
Wrapping Up
48(1)
4 Consuming Backing Services with JRuby
49(24)
What Are Backing Services?
49(1)
Storing Sessions in Memcached
50(6)
Running Background Jobs with Sidekiq
56(6)
Message Passing with RabbitMQ
62(9)
Wrapping Up
71(2)
5 Deploying JRuby in the Enterprise
73(14)
What Is an Application Server?
74(1)
Getting Started with TorqueBox
75(2)
Scheduling a Recurring Job
77(1)
Using the Cache
78(3)
Deploying to the Public Cloud
81(1)
Deploying to Private Infrastructure
81(2)
Using a Commercially Supported Server
83(3)
Wrapping Up
86(1)
6 Managing a JRuby Application
87(22)
Creating a Memory Leak
87(1)
Inspecting the Runtime with VisualVM
88(5)
Inspecting the Runtime with JMX
93(3)
Invoking MBeans Programmatically
96(2)
Creating a Management Bean
98(2)
Using the JRuby Profiler
100(3)
Analyzing a Heap Dump
103(4)
Wrapping Up
107(2)
7 Tuning a JRuby Application
109(14)
Setting the Heap Size
109(2)
Setting Metaspace Size
111(1)
Configuring Heap Generations
112(2)
Choosing a Garbage Collector
114(2)
Benchmarking the Garbage Collector
116(4)
Using invokedynamic
120(1)
Wrapping Up
121(2)
8 Monitoring JRuby in Production
123(10)
Installing the New Relic Gem
123(3)
Creating a New Relic Alert
126(1)
Handling Errors with Rollbar
127(4)
Customizing Rollbar Reporting
131(1)
Wrapping Up
132(1)
9 Using a Continuous Integration Server
133(10)
Installing Jenkins
133(1)
Installing Jenkins Plugins
134(1)
Creating a Git Depot
135(1)
Creating a Jenkins Job
136(3)
Enabling Continuous Delivery
139(1)
Wrapping Up
140(3)
Index 143
Joe Kutner has been building JRuby applications since 2007 for clients including IBM and NASA. Today, he is the JVM Platform Owner at Heroku, a Platform as a Service support for JRuby and Rails. Joe also contributes to several JRuby projects, including Warbler and Torquebox.