Merken

Real World Docker for the Rubyist

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
thank you and thank you do that it has fed to everyone for holding told told the in the last session before the last keynote on friday but my name is Jason Clarke on so I could talk to you about real world talk of review and this talks Genesis really comes out of the fact that the company that I work for new relic deploys a lot of our services using doctor and hear a lot of hype about offer here a lot of people saying you should use it and then wildly diverging opinions about how to use this tool Decker turns out to be a toolkit that gives you a lot of options you can pick from and so what I wanted to do was I wanted to give you a presentation that tells you how the way that you can approach Dr. this is tried-and-true tested stuff that we've been doing any relic for actually the last couple of years we got in the dark pretty early on so we've experienced a lot of a lot of leading edges and we've experienced a lot of things and made our lives easier so
this talk is going to take the shape of a story and this story is going to be about to developers Jane who is a new new relic employee and has a great idea for a product a service that she wants to run weeks we encourage experimentations with the lines of code serviceable the metrics for for how many lines of code you have super useful like you know we we wanna let people experiment in and see how that goes and Jill who is someone who's been at new relic of a little longer has some experience and can help answer some questions so and
as we are a public company this is a safe harbor slide which says I'm not promising anything about any features please don't sit us please don't assume anything based on me making up stories about services that we might develop OK so we're all clear this is a this is a bit of fiction but it will help us find how we used occuring give you a picture of the ways that you might be able to apply the so you know 1 of the 1st
questions the Jane has a she comes in as wide as new relic you stop at all what what is the purpose what's the the sort of features that drove us to this technology in 1 of the big component of it is the packaging that you get dark Sedaka provides and what are
called images images and basically the big binary package of files it's essentially a file system a snapshot of a piece of code and dependencies that has that you can then distribute around and run and at this point genes I don't ever have heard about this the images these images you can build off of them you can take so for instance there's a official Ruby image that maintained by Dr. you can use that image and then put your Ruby code into an image that you build off of N. Jain causes jolt things like OK so this is slightly confusing have heard
about images and I've heard about containers like that what's what's the relationship here and so the relationship is that an image is kind of the basis of what you're going to run serve the deployable units where a container which does not really resonate for me in the term that is the running instances something like that now the the way that you can think of this is if you draw an analogy to Ruby the image would be like a class and review so this defines what's there defines what's possible and what's all and then the container is like an object instance the unit of new it's a individual running piece about OK so we've got Dr. images and then those we can deploy as running containers that do our application run our code I cannot are staging in production environments so that you know there are lots of
ways to package of your stuff I mean you could just shovel files out there you could make far out of it you know that's not enough to tell us why we would 1 use darker and that brings us to the other major thing the doctor brains and that's isolation so for most of us
we don't have our ap set up in such a way that you know 1 host will be completely maxed out by now that's on we may want to be able to share those resources and run multiple things across multiple machines to increase our resiliency news resources and traditionally you might have done that in some fashion like this you have your server you've got in a different directories where you keep the different absolute there and deploy and and run those things on active in house all the problems here are pretty obvious when you look at it and see the thing sitting next to each other they're all sharing the same neighborhoods they could interfere with each other's files they could interfere with processes that are running at the sharing the same uh memory on the machine and there are lots of ways of these 2 applications that are running there might interfere with each other Dr. gives us a way to contain that to kind of keep those pieces
separate and they still use the same kernel this is not like a B M where there some supper operating system but Dr. provides insulation so the each of those running containers appears to itself is that it is the only thing that is in the universe only sees its file system a subset of that it has you can put constraints on how much CPU and memory users and so it minimizes the possibility of those 2 add applications interfering with 1 another despite the fact that the running on the same coast so this is a pretty attractive thing for us and to be able to have sort of shared host that we can deploy a lot of things to you very easily without having to worry about who else in the neighbor right so clearly in a James new
developer has shown up how we get started well doctors a very Linux-based technology and there has to be running on a Linux system with the Linux kernel and you know a lot of us here don't run linux systems directly Miramax of windows and fortunately DARPA toolbox toolkit is available so
this comes from Dr. it's the kind of sanction way to set up a development environment we have to get the DARPA tools installed on and on Linux systems and so once we have that then we can get down to actually I'm writing on images to construct a an image for the woman deploy so gene you sits sits down until the pairing and you'll
has her write this in a file called doctor following the root of her application and emerging recognizes a little of this she had been done some reading about doctor that from says what image should I start from is on building the image for my app but that's all the JEL tells a derived and she cycled shouldn't should there be some other things like this looks more like a doctor follow I've seen you know how that's working directories and copies and runs in a bunch of shell commands and things there setting things up so to change really confused
about what's going on you know this is an image that we're using from new relative we've got an the where's the rest of the DNA profile and also look at this is that fair question but you know running codes awesome let's get you think deployed to staging and then we'll dig into this later and look at how that very simplified darker file actually provides us a lot of value and and shared resources such having written this basic little
block profile Jane goes to the terminal and writes this command line sources darker build the minus T provides a town for the image that we're going to construct and tells it to work in the current directory with that DOS and then once we've done that there will be a whole bunch of output that appears at the command line as Dr. goes through takes that base image and then runs the various pieces that baked into that image to build out the package of your app now if you have errors in your doctor following have problems file permissions things that go wrong this would be the point when building that would tell you you'll see output from those commands there but once it successful if we ask Dr. what images it knows about it will give you a listing in here will see our LOC service image that we build a given a default tagger the latest because we didn't tell it to give it a particular tag and and that image is the the runnable copy of our application that we can do something about this is all all well and good for Jane on her local machine but
clearly if this thing is going to go into a staging environment that image needs to get from her computer somewhere else and to fill this gap and there are a variety of things you
can do called Dr. registries now by default and darker runs 1 called Doppler have this is what all the darker tools will default to if you don't specify as you push and pull images of where we look for it I there are alternatives to 0 so at relic we ran into a problem when they i deprecated what version of Dr. you could use more quickly than we had moved some of our systems off of that and so we had to go looking for some alternatives as well and 1 of them that we've had pretty good success with his called the I know it's still kind of funny that that's how the word gets pronounced and and that that is very similar to Dr. have applied to a nice web you why you can push and pull images that they have a paid service you can have those be private but and so that's been 1 of the major alternatives that we've gone to is we've moved off the darker another alternative is well
is a piece of software there do district now don't history is a little more bare bones but what it what you do is that let you store images on S 3 in your own S 3 bucket so it sort of takes that 3rd party provider out of the picture which can be important if you have critical deployments you know if we have a deployment depends on DARPA have been up of DARPA have as down we can't play our stuff you know that might be a problem for you depending on your organizational structure and scale
right so we have an image we have this this picture of what genes as service looks like she wants to get running so she wants to go get the I get this started up out in our staging environment and so on how does she do that well at new we developed a tool called centuries
now typically if you wanna just run a doctor image and create a container of adaptable structure application of you would say doctor run in in the image and that image has a default command baked into it which is what will get invoked and then this starts running if you run it in this fashion will be blocking you'll see the output this coming out of the container is the commands right and so you can imagine that this is something you know you could go out to machine some on the staging of cluster and go tell it to run these containers that would that would work but
unfortunately I if you're company gets any sort of size and scale you probably want things running on multiple hosts and you probably have a lot of computers are out there and interacting with those individually and is problematic and so that was where train
came and now this is certainly not the only way to solve this problem and all briefly refer to some other possibilities later on but when you relic started with Dr. these things didn't exist and so some training is a ruby gem that allows you to work against multiple Barker hosts in easily a push and pull and deploy your images into rolling restarts and things like that 1 of the other big powers of century in brains is that it is based
off of configuration files and these are things that you can then check and source control you conversion and have a sort of a central point where you know what's deployed in your doctor environment rather than individuals going out to boxes were starting containers that you don't know anything about if you run everything through century and you have a central record of what's actually going on so centurion bases these rate these and these configs off of rate so that they have some amount of dynamic programming you can do in Ruby so you define a task for a given environment that you want to play to so in this case we made task for staging environment we tell it where Dr. image we want it to question that to Paul onto those hosts and that allows us to have a grab latest you can also tell a different tabs so if you had different versions of the service and you wanted to blow a certain 1 could do that and then to handle that issue of having lots of host so we might wanna start on you can specify multiple hosts this century and will then go and restart deployed services to so with that it's pretty easy to get some insurance started
it's just gem you install it and it installs an executable for you called centurion unsurprisingly there's a number of flags of it'll take the basics are intelligent environments you tell it the project where it should have find the configuration and then you get a command there's a couple different commands will discover the deploy and say go out there and start these
things so James little nervous I mean she's hardly better here at all but you know she is the sole gonna we're ready yeah go she kexec sintering command and
what you'll see is a lot of output as it connects to the various hosts it will go through then it will pull all the images down to those with all the boxes that you need have the image that you're going to then start and then 1 by 1 it's going to stop any container that's running for that at that particular service on the box and then start a container up for you based off of that so after it's connected there's also options let it hit a service status check in point so you can do rolling deploys where you make sure that things are actually up and running before you start to the next host and shut things down on so having done all these things
I it's it's been chips things staging Jane is able to test our code see that things are working swimmingly and goes home for the day feeling very accomplished but was to bed comes back the next day unfortunately things were not as
great as she thought the service is not there
where you're at go well it's time for a time for the tables turned Joe's gonna ask a
few questions but j incidences as well we're really log into let's let's start trying to figure out what happened here and Jane looks through the code and she had had crude the line from somewhere that she wasn't
really clear about that in her production configuration for her rails out but it looked like it was a standard practice around relic have uh all of the logging go to standard out rather than going to files that would get written inside the doctor contain OK so that that being the case is actually put Jane and a really good position because I knew relics infrastructure where we run our the Doppler hosts and actually takes all the standard out the kinds of doctors like we saw when you run a container you see what's going to standard out from that so we're able to capture it in may actually forwarded to a
couple different places but we before it into an elastic search instance which runs cabana which is a fairly common sort logging infrastructure of to referred to as the elk stack and elastic something with an analog and forget and cabinet and then also we can actually take that opportunity to send things to our own internal database and that database called insights and this lets us do analytics query across these lots they enough you could set things up to send these logs that are coming out your docker containers anywhere you want but I highly recommend that if you do use doctrine production in this way you make sure that all of the log you can is going out of the containers and not getting written inside of them because it will give you better visibility to it for 1 by getting it out also prevent the file system sizes from getting huge in the docket containers themselves alright so they take a look at
the logs there's not really anything there unfortunately you don't always hit a home run and 1st go so it's time to take a little closer look at the containers themselves well that's actually something that that you're able to do you and darker provides the commands for it
so I mean here now we're specifying a minus capital H that's and pointers to a different host so by default doctors going to be talking to a doctor running on your local machine and so this lets us go point at a staging environment and the command way funding in their saying PS lists the running docker containers that are on that it's in here we see a container ID it has a nice try what should be fun for us to tight but that's an unidentified for the individual running container that we've got going on there no looks like it's still there it's running so we can do from there is we can say exactly rather than run and give it the container right e the minus i t set things up to be interactive and so this will actually give us a background onto that topic contain now this depends on batch being installed on the darker container that were connecting 2 and there's a variety of other things that could interfere with us but we have things set up so that we can do this had to do any sort of debugging that we need on those containers as the running in a production and staging environments and they look around they see the processes are gone it's not exactly clear what's going on but they eventually I dig up some stuff that looks like the might and something's happening with memory and that
tickle something in the back agile's brain she remembers another project that they had and that they have some similar problems were things just seem to be disappearing like processes would just go away with no trace so that they could see and the problem there was memory so that the lines of code service currently is talking and the good 300 may not totally crazy for Orelle's up a a little bit and that was the key that they needed to figure out this problem with things getting killed so like we talked about way at the beginning of 1 of the key things about how darker provide you isolation is a you can set limits on the containers for how large they can get and what memory they can consume this prevents the individual containers from interfering with other things that are on the same host and it turns out the 256 name was about the limit there was being set by default if you didn't specify anything so as soon as you got past that been doctors and infrastructure would kick in and it would just kill processes to free up the memory of this is clearly not a good situation so fortunately
we allow for configuring that so in a century and configured can save memory what give us 2 gigabytes and what this actually correlates to is a command-line flag you can give the doctor to tell it how much memory you and basically any of the commands that you can give any the flags that you can sense to doctor when you're running things to modify the environment and tell it differently how to run stuff are available through the century effects so you have a source controlled place to do all the changes that you might wanna do how your containers right Our this is great we've got 2 gigs things stay up they keep running notebook but we actually asked for a little more memory than we really needed and James like
well we should probably you know the global but more performance a little out of this evening and I denotes and staging and be nice to have a little more room so I want to increase the number of Unicorn workers JOLs responses to try the in so darker provides
flags when you're running to let you set environment variables that will be passed along into the container and this is actually a really fundamental part of how you should structure your doctor uh systems so that things get passed in from the outside so when we say minus the Unicorn workers ones work inside that container it's just an environment variable like you've probably seen in many other places 1st set up we
have a stamp fairly standardized unicorn configured what we do is we look for the Unicorn workers environment we turn that into an integer tell it to run the number of workers that we and so are darker image can be used to scale up a down to run larger or smaller numbers of workers without us having to construct a new image changes that figuration as you might expect century and supports this in fact this is 1 of the key features of how we use century and is that we drive as much of the can figure out of the codon out of the file system into the environment as we possibly can and so you can say in bars give it a hash to give it the names of that now this is not the only thing you might wanna configure your database him all file in a typical rails that gets passed through E. R. B. before it's actually 1 and so you can do things like that where you can parameterise potentially offer the environments when we run in our production and staging we can be explicit about where to go connect to our databases or 1 of the niceties is since this is just Ruby code inside of the R. B. and braces there we can also give you default so if you're running the rails that locally it's gonna work is gonna find the things that it needs the similarly application-specific configs and are something that we can rely on and the environment as well so in your in your application that B you can set configured values and you can set these 2 arbitrary names arbitrary things that you want to pass around and then those will be available throughout the rails out so here we take i were looking for another service arena talk to we set the URL and we have a default to fall back to we set timeouts and what this does is this gives us 1 central place in rails out that we will see all of the things that we can configure through the environment all the knobs and switches the you might want to control accessing this from other places in your code is a simple saying rail stop configuration dot in the access to that you specified so here we can get the super service URL and find out that we were talking about in use those throughout our system now some of you may have heard of the 12 factor
and this is the thing that broke who has promoted this got a lot of principles around how to run applications well Introduction this whole environment driven thing wallet applies very strongly to Dr. it's not limited there and this is 1 of the key tenets that they have with this is also a really good idea to drive things through the environment as well but for security reasons if you have secrets you have password you have since pieces of information if you put those into your source code or put them in files that are in your doctor images if somebody gets a hold of that Dr. image they will be able to come to see what that stuff is so if you're if darker have compromised or some other place does your secrets you don't want them to be into those images by putting them in the environment the only there at run time and someone would have to have access to the containers to be able to get those that bits of information that you don't want our so this is all
well and good genes Austin about the work that's going on but she really wants to understand better so that line darker father we show that the right she just like wrote 1 line to see from this image how does that actually work what turns out that the relic we put a lot of effort internally into
building shared darker images on top of other pieces of the of the darker infrastructure that we've got from the world at large to make our life simpler and begin the things that are shared across the applications so based
builder there was the name of the image that we graph from that to start and so this includes a lot of our standard ways of approaching things new relics so for 1 hour for various historical reasons we run mostly office and tossed that's what our ops folks a are most comfortable with this so we derive ourselves off of this impulse image rather than a lot of the base through the images reader al-Qaida bombed to Linux what we know that this is something that people are running Ruby off of and so 1 of the 1st things that we do in this space images we install versions for you now we end up using RBM the RBM and to do that is not strictly necessary cuz there's not going to be version switching going on and it just happens to be the tool that is most commonly used in the relic for switching you can get a Ruby installed on 2 Dr. image however you would choose to once we have that Ruby version installed we can start putting other things that we assume people are going to use so for process management we use the application called supervisory so we can install that at most of the time you're running something that's of web service sort websites sites and type so we run that through genic so we put that into the space image In fact we can go even further we can gem install Bombela and then uh rehash so that that at executable for bundling is available and you know this is great great for finding all these things that alike shared between these applications and taking that duplication out making it simpler for people to build their images so why not just bundles all get all the stuff right well here we hit a roadblock and it's pretty obvious when we try to build what's wrong
the base builder this is a base image this isn't the application itself so we don't actually know what you're Jim volunteer someone is going to build the AP on top of this and so we can't go into the bundle install when we're making the basis we don't know what's going to get into that actual house but fortunately Dr. provides us the that we need to do what we really want which is to say when somebody uses
this image I have commands and I want you to run and operas columns for that is on build so in the doctor command you put into your image if you say on build before it it will wait around that command until after somebody has already used your image in their own doctor file and so we can do things like wait until somebody uses this in their out and then go copy the gym violence and bundle install so we get their copy of dependencies but we don't have to have them right the lines denote ago bundle due to correct things in their particular doctor from the In fact we push this approach quite a ways and provided not just standard things that everybody does but options that people may want to choose so unicorn is use pretty broadly at new relic it tends to be the default Web server but there are people that are using puma and all like to try that out so what we've done is we've created the scripts that allow for those sorts of configurations to be a one-line thing you can put in your application stock file in all of these have to be is a script that modifies whatever configs you need to on just to get the effect that you want so in our case this is just a matter of changing out the supervisor configs for which I app server to start up and then swapping in a Puma configurations that the Unicorn configured the act itself but this is a line thing for somebody to do in their out and be able to to try out the fact we've even gone so far is too bright helpers for installing other things that people might want like Python we have some uh some teams that have background processing that runs in Ruby and then has in Python that it needs to invoke and so we can provide simple wrappers baked into these basis images to smooth the path for app developers as they do their work right so it it's a fun technique it's fun to see which things you can pull out and make it so that people don't have to think about but let's get back to some
codes to Jane keeps writing her out she's working on this line to code service and she wanted to write a file somewhere she just come pick the root directory date to go right it and she's giving an air out of it so she goes things Joe tokens over they take a look at that and I it's a
you know again a pretty straight forward error message that is not only the why this is happening permission denied should try to put this father then Jill you know being fairly
experienced knows just what the problem is the problems with nobody and nobody whose nobody well nobody is
an identity that we have on our our Linux machines that has fewer privileges than route so it's actually a user there
we run our things in inside of our containers by default and so here this is not super relevant in all the details but this is how supervisor starting about and we say users nobody there things that the dark level where you can control this as well and that this can't makes Jane a little confused
because like she's heard from many different people about how darker runs as root and isn't that fine because the containers are isolated and while it is OK to do that and it's not it's a sensible wide Dr. chosen that is the default it doesn't mean that you can crank things down further so if you are writing your own applications you can be more defensive and ockerers itself and by running as nobody inside of our containers we give ourselves extra protection in case there is some exp or some problem with Dr. that would let them elevate root privileges inside of the container to the outside hopes so running things in its secure the mode is you can within the boundaries of are in your control will end up giving you a safer result in the end right so Jane gets that fixed up search writing things in a location where she's allowed men in maybe a little later comes around saying here I wanna write some tests like how what happens darker fit into that's but there are some ways that you can you can work with Dr. to make sure that you test a running in a realistic environment like where you're going to deploy the simplest
most straightforward thing you can do is you can run alternate commands against the contain against the images that you bill so here we see Dr. run against an image of our lines of service and we just old bundle exec break and it goes off and it runs the tests inside of the container now this presumes that all the configuration is best that's necessary is therefore needs database connections you have to figure out how to feed those things in but AT base all it needs to do is run that Ruby code inside of the container instead of running your full web applications but unfortunately this has a problem and that's the fact that this relies on the image that you build having your current code and I don't know about you I occasionally will edit my code well working on if you make a change to your testing make a change to production code you have to rebuild that image to be able to get those tests run against the current thing that you're doing and I don't know about you but this would make me very sad anything that gets in that loop of making it so I have to do something extra before I can do my test is not a really great experience fortunately at Dhaka does have some options that will let you get out of that and and do things in a little different way and that is with a mounting volumes so here we have a doctor Run command it's running against our airlines accrued service image and that minus B is the important part so what that is saying is take what's on my local host my host were running at source my out and make it so that that appears inside my container that slash test out and so this amounts that in without rebuilding the image and so what we actually have happening in a relic of most of our our tests is they run against the darker image but they just melt the current code into that image rather than rebuilding it from scratch you have to do a little directory lending make sure you're in the right place to go run the code but otherwise this is a very good approach to keep you from rebuilding images of time so
like moves on James got more and more things issues wanting to do with the the service in as often happens you maybe is looking sidekick to do some background processing and she needs a red instances figures so I need to talk to somebody to provision that a set that up what it turns out that what we built with Dr. allows her to kind of self-serve that and I have stuff deployed through the same mechanisms so what we have is
we have a image already constructed that we use internally that has reticence stalled and that takes all that's configuration to environment variables so all the j needs to do to get a running rabbits instance into staging of production is to create this configuration and go deployed at the same way that she's been doing with her at this is a powerful approach like you can do this with anything where you've got some sort of appliance some sort of just code that you would like to be able to have people parameterizing run without tampering with that and if you build the images to drive off of the environment then people can just take that and run with it and just user can out of box so there's a lot of talk about
Dr. there's a lot of things that are going on century you know came out of the need that we had a couple years ago a new relic but there's a lot of other things that a an ecosystem that might be of interest and or something you might wanna pick up today so 1 example
that is darker swarm now this comes from Dr. it's it is uh software that easily allows you to control a cluster of hosts so the sort of uh staging environment that we have the purpose form is a good way to sort of bootstrap yourself into running and that type of environment something that we're looking at a potentially either evolves and train into over used to replace it is they a particle mazes and measles in conjunction with a thing called marathon delighted to have more dynamic acid scheduling for your containers so rather than saying I want to run this on hosts a B and C you would tell mazes I would like to run 3 instances of my image please go find somewhere to put them and it would put them out there and has some really nice properties around resilience if it drops 1 of those instances because something crashes mazes can start back up for you automatically you can scale things dynamically to with a
similar technology that's for this sort of container orchestrations to communities from Google and there are a lot of other things that are out there that happening in the space there's a lot of people working out to make this a better workflow right so we've come to the end of
Jane Ángel story we've looked at how you can use and trained to deploying control multiple darker hosts we've looked at how using the environment to dry the configuration allows things to be more dynamic and controlled we've looked at some tips and tricks around building shared images so that you can spread best practices within your organization and not repeat stuff looked to some security and testing a little peek at the future were things might be going I hope this has been of use to you and hopefully you have to assess if you choose to use Dr. your company thank you few
so so the question was where the doctor for lives and yeah typical practice for us is that the the root of your Rails that is where the door profile would live it doesn't have to you can put it in other locations but that's been the simplest us the convention that we followed yes so that right so the question is between vagrants and for similar sorts of workflows of testing and developing a doctor I'm from what I've experienced opera started very fast so if you have a prebaked image like the image building takes a while but actually starting container is really quite so it would definitely be worth looking into i think it provides a similar things to vagrant and is a little lighter weight that's 1 of the selling points there act so the question was what concrete usage to have a this I think at last count we had a couple hundred services that are running on this internally and it is not everything that we run but there are a number of our bigger older applications and especially the data ingested that are converted over to Dr. but pretty much any of our new products that have been developed in the last year to had been deploying into our our cluster so yes so that the question was the deployment workflow workflows of building a new image like render test build a new image and then deploy that image and yeah that's that's correct me if we run things through a CI system we happen use Jenkins but it's a fairly up to you exactly how that flow happens I showed a lot of us using the command line directly to do those deploys we don't actually do that much in practice you have a central CI server do it but all that it's doing is calling centurion from a little shell scripts the same way that you could from your local machine yes to the question is what we do about things like a database migrations NASA compilation of asset compilation very often we will do it image built time I didn't show it here but that is a common thing for us to do in constructing the image and we have some other techniques that were room playing with for externalizing images entirely from or else out sticks that out of the picture and database migrations at the database currently and probably for the foreseeable future does not actually live and itself and so we will tend to have another environment where we would potentially use that proper image to go running the migrations like use the image run that command to go talk to the database and you those migrations but it's not part of the individual deploys its normally scheduled separately as part any questions so what about the fact that migrations might break currently running instances that something that we kind of have to manage ourselves at this point but it's certainly something you could build more infrastructure around we tend to just have a very conservative cadence for when we do migrations in the apps that have those those sorts of our set up so red light is on so I'm out of time to be on the mind but I have to talk to anyone who would like to afterwards thank you for your attention and and I behind my file
Dienst <Informatik>
Reelle Zahl
Kombinatorische Gruppentheorie
Computeranimation
Konfiguration <Informatik>
Rechenschieber
Bit
Shape <Informatik>
Dienst <Informatik>
Einheit <Mathematik>
Softwareentwickler
Biprodukt
Code
Gerade
Computeranimation
Punkt
Einheit <Mathematik>
Dateiverwaltung
Zusammenhängender Graph
Elektronische Publikation
Binärcode
Code
Bildgebendes Verfahren
Quick-Sort
Computeranimation
Instantiierung
Objekt <Kategorie>
Einheit <Mathematik>
Klasse <Mathematik>
Basisvektor
Kartesische Koordinaten
Term
Programmierumgebung
Analogieschluss
Code
Bildgebendes Verfahren
Computeranimation
Instantiierung
Nachbarschaft <Mathematik>
Nebenbedingung
Server
Prozess <Physik>
Kartesische Koordinaten
Physikalisches System
Zentraleinheit
Elektronische Publikation
Quick-Sort
Computeranimation
Kernel <Informatik>
Virtuelle Maschine
Multiplikation
Festspeicher
Server
Dateiverwaltung
Verzeichnisdienst
Grundraum
Installation <Informatik>
Bildschirmfenster
Physikalisches System
Softwareentwickler
Programmierumgebung
Bildgebendes Verfahren
Computeranimation
Kernel <Informatik>
Faserbündel
MUD
App <Programm>
Nabel <Mathematik>
Installation <Informatik>
Profil <Aerodynamik>
Kartesische Koordinaten
Elektronische Publikation
Computeranimation
Codierung
Wurzel <Mathematik>
Verzeichnisdienst
Bildgebendes Verfahren
Lesen <Datenverarbeitung>
App <Programm>
Punkt
Dokumentenserver
Dämon <Informatik>
Virtuelle Maschine
Profil <Aerodynamik>
Mailing-Liste
Kartesische Koordinaten
Computer
p-Block
Quellcode
Computeranimation
Spezialrechner
Dienst <Informatik>
Radikal <Mathematik>
Programmierumgebung
Verzeichnisdienst
Default
Bildgebendes Verfahren
Varietät <Mathematik>
Funktion <Mathematik>
Fehlermeldung
Zentrische Streckung
Versionsverwaltung
Doppler-Effekt
Quick-Sort
Service provider
Computeranimation
Benutzerbeteiligung
Dienst <Informatik>
Software
Äußere Algebra eines Moduls
Wort <Informatik>
Datenstruktur
Drei
Default
Bildgebendes Verfahren
Konfigurationsdatenbank
Parser
Kartesische Koordinaten
Computeranimation
Unendlichkeit
Virtuelle Maschine
Dienst <Informatik>
Wurzel <Mathematik>
Anpassung <Mathematik>
Datenstruktur
Programmierumgebung
Default
Bildgebendes Verfahren
Funktion <Mathematik>
Zentrische Streckung
Multiplikation
Wellenpaket
Computerunterstütztes Verfahren
Bildgebendes Verfahren
Quick-Sort
Computeranimation
Leistung <Physik>
Zentralisator
Subtraktion
Punkt
Quader
Diskretes System
Versionsverwaltung
Zahlenbereich
Programmierumgebung
Elektronische Publikation
Bitrate
Quick-Sort
Computeranimation
Konfiguration <Informatik>
Task
Datensatz
Dienst <Informatik>
Task
Fahne <Mathematik>
Stützpunkt <Mathematik>
Projektive Ebene
Optimierung
Programmierumgebung
Bildgebendes Verfahren
Spezialrechner
Dienst <Informatik>
Punkt
Quader
Bildgebendes Verfahren
Computeranimation
Konfiguration <Informatik>
Funktion <Mathematik>
Dienst <Informatik>
App <Programm>
Web Site
Inzidenzalgebra
Gerade
Code
Computeranimation
Web log
Tabelle <Informatik>
Subtraktion
Ortsoperator
Datenhaltung
Abfrage
Keller <Informatik>
Konfigurator <Softwaresystem>
Analytische Menge
Biprodukt
Elektronische Publikation
Login
Doppler-Effekt
Ranking
Quick-Sort
Computeranimation
Dateiverwaltung
Elastische Deformation
Analogieschluss
Standardabweichung
Instantiierung
Punkt
Prozess <Physik>
Existenzaussage
Biprodukt
Login
Quick-Sort
Computeranimation
Spezialrechner
Virtuelle Maschine
Rechter Winkel
Stapelverarbeitung
Zeiger <Informatik>
Programmierumgebung
Default
Summand
Varietät <Mathematik>
Soundverarbeitung
Bit
Prozess <Physik>
Mathematisierung
Quellcode
ROM <Informatik>
Code
Computeranimation
Dienst <Informatik>
Task
Notebook-Computer
Festspeicher
Fahne <Mathematik>
Inverser Limes
Projektive Ebene
Schlüsselverwaltung
Default
Gerade
Variable
Fahne <Mathematik>
Mereologie
Endogene Variable
Zahlenbereich
Physikalisches System
Programmierumgebung
Computeranimation
Eins
Zentralisator
Hoax
Bit
Konfiguration <Informatik>
Mathematisierung
Zahlenbereich
Kartesische Koordinaten
Code
Computeranimation
Font
Task
Fahne <Mathematik>
Hash-Algorithmus
Vererbungshierarchie
Dateiverwaltung
Passwort
Default
Bildgebendes Verfahren
Prozess <Informatik>
Raum-Zeit
Computersicherheit
Datenhaltung
Zwei
Indexberechnung
Rechenzeit
Programmierumgebung
Physikalisches System
Quellcode
Elektronische Publikation
Biprodukt
Teilbarkeit
Konfiguration <Informatik>
Dienst <Informatik>
Ganze Zahl
Information
URL
Programmierumgebung
Schlüsselverwaltung
Videospiel
Güte der Anpassung
Kartesische Koordinaten
Gerade
Bildgebendes Verfahren
Computeranimation
Homepage
Faserbündel
Nichtlinearer Operator
Web Site
Prozess <Physik>
Graph
Installation <Informatik>
Antwortfunktion
Versionsverwaltung
Kartesische Koordinaten
Raum-Zeit
Quick-Sort
Computeranimation
Office-Paket
Modallogik
Web Services
Datenmanagement
Basisvektor
Datentyp
Installation <Informatik>
Faserbündel
Bildgebendes Verfahren
Faserbündel
Soundverarbeitung
App <Programm>
Fehlermeldung
Prozess <Physik>
Installation <Informatik>
Kartesische Koordinaten
Elektronische Publikation
Quick-Sort
Computeranimation
Konfiguration <Informatik>
Dienst <Informatik>
Benutzerbeteiligung
Basisvektor
Codierung
Server
Skript <Programm>
Wurzel <Mathematik>
Softwareentwickler
Verzeichnisdienst
Default
Bildgebendes Verfahren
Faserbündel
Gerade
Virtuelle Maschine
Nichtunterscheidbarkeit
Routing
Computeranimation
Fehlermeldung
Faserbündel
Resultante
Softwaretest
ATM
Konfiguration <Informatik>
E-Funktion
Kartesische Koordinaten
Computeranimation
Übergang
Arithmetisches Mittel
Randwert
Softwaretest
Wurzel <Mathematik>
Gamecontroller
URL
Wurzel <Mathematik>
Default
Programmierumgebung
Fitnessfunktion
Faserbündel
Prozess <Physik>
Wellenlehre
Mathematisierung
Web-Applikation
Code
Computeranimation
Loop
Dämpfung
Kontrollstruktur
Spezifisches Volumen
Figurierte Zahl
Bildgebendes Verfahren
Gerade
Einfach zusammenhängender Raum
Softwaretest
Kraftfahrzeugmechatroniker
Elektronische Publikation
Universal product code
Datenhaltung
Dämon <Informatik>
Quellcode
Instantiierung
Konfiguration <Informatik>
Dienst <Informatik>
Menge
Mereologie
Verzeichnisdienst
Faserbündel
Instantiierung
Variable
Quader
Biprodukt
ROM <Informatik>
Programmierumgebung
Bildgebendes Verfahren
Code
Quick-Sort
Computeranimation
Konfiguration <Informatik>
Instantiierung
Wellenpaket
Kategorie <Mathematik>
Diskretes System
Atomarität <Informatik>
Bootstrap-Aggregation
Systemzusammenbruch
Raum-Zeit
Quick-Sort
Marketinginformationssystem
Computeranimation
Scheduling
Bildschirmmaske
Software
Datentyp
Partikelsystem
Programmierumgebung
Instantiierung
Zentralisator
Konfiguration <Informatik>
Punkt
Gewicht <Mathematik>
Nabel <Mathematik>
Selbst organisierendes System
Compiler
Zahlenbereich
Kartesische Koordinaten
Zählen
Computeranimation
Spezialrechner
Virtuelle Maschine
Softwaretest
Migration <Informatik>
Computersicherheit
Volumenvisualisierung
Skript <Programm>
Wurzel <Mathematik>
Bildgebendes Verfahren
Softwaretest
App <Programm>
Datenhaltung
Computersicherheit
Gebäude <Mathematik>
Profil <Aerodynamik>
Ähnlichkeitsgeometrie
Physikalisches System
Biprodukt
Elektronische Publikation
Datenfluss
Quick-Sort
Konfiguration <Informatik>
Dienst <Informatik>
Mereologie
Server
Gamecontroller
URL
Programmierumgebung
Instantiierung

Metadaten

Formale Metadaten

Titel Real World Docker for the Rubyist
Serientitel RailsConf 2016
Teil 68
Anzahl der Teile 89
Autor Clark, Jason
Lizenz CC-Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Unported:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen und nicht-kommerziellen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen und das Werk bzw. diesen Inhalt auch in veränderter Form nur unter den Bedingungen dieser Lizenz weitergeben.
DOI 10.5446/31550
Herausgeber Confreaks, LLC
Erscheinungsjahr 2016
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract Docker’s gotten a lot of press, but how does it fare in the real world Rubyists inhabit every day? Together we’ll take a deep dive into how a real company transformed itself to run on Docker. We’ll see how to build and maintain Docker images tailored for Ruby. We’ll dig into proper configuration and deployment options for containerized applications. Along the way we’ll highlight the pitfalls, bugs and gotchas that come with such a young, fast moving platform like Docker. Whether you’re in production with Docker or just dabbling, come learn how Docker and Ruby make an awesome combination.

Ähnliche Filme

Loading...