Merge branch 'master' of https://github.com/kubernetes/kubernetes.github.io into release-1.7

* 'master' of https://github.com/kubernetes/kubernetes.github.io: Fix a couple of typos in tasks/debug-application-cluster/audit.md Add an explanation of how the kubeadm kubelet dropin file works and a note about cAdvisor All files for both new case study pages (#4235) Add empty layout template
Merge pull request #4244 from mattmoyer/patch-1
2017-06-30 17:58:32 -07:00 · 2017-06-30 17:57:49 -07:00 · 2017-06-30 17:57:19 -07:00 · 2017-06-30 17:55:02 -07:00 · 2017-06-30 09:27:05 -05:00 · 2017-06-30 01:19:35 -07:00
38 changed files with 1645 additions and 137 deletions
@@ -0,0 +1 @@
+{{ content }}
@@ -0,0 +1,127 @@
+---
+title: Box Case Study
+layout: none
+class: gridPage
+cid: caseStudies
+---
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+      <link href="https://fonts.googleapis.com/css?family=Roboto:300,400" rel="stylesheet">
+      <link rel="stylesheet" type="text/css" href="/css/style_box.css">
+    <title>Box Case Study</title>
+  </head>
+<body>
+
+
+<div class="banner1">
+  <h1>CASE STUDY: <img src="/images/box_logo.png" class="logo" width="10%" style="margin-bottom:-6px"><br>
+    <div class="subhead">An Early Adopter Envisions
+      a New Cloud Platform</div>
+  </h1>
+</div>
+
+
+<div class="details">
+    Company &nbsp;<b>Box</b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Location &nbsp;<b>Redwood City, California</b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Industry &nbsp;<b>Technology</b>
+</div>
+
+<hr>
+
+<section class="section1">
+
+<div class="cols">
+  <div class="col1">
+
+      <h2>Challenge</h2>
+        Founded in 2005, the enterprise content management company allows its more than 50 million users to manage content in the cloud. <a href="https://www.box.com/home">Box</a> was built primarily with bare metal inside the company’s own data centers, with a monolithic PHP code base. As the company was expanding globally, it needed to focus on "how we run our workload across many different cloud infrastructures from bare metal to public cloud," says Sam Ghods, Cofounder and Services Architect of Box. "It’s been a huge challenge because different clouds, especially bare metal, have very different interfaces."
+        <br>
+  </div>
+
+
+  <div class="col2">
+    <h2>Solution</h2>
+      Over the past couple of years, Box has been decomposing its infrastructure into microservices, and became an early adopter of, as well as contributor to, <a href="http://kubernetes.io/">Kubernetes</a> container orchestration. Kubernetes, Ghods says, has allowed Box’s developers to "target a universal set of concepts that are portable across all clouds."<br><br>
+
+    <h2>Impact</h2>
+      "Before Kubernetes," Ghods says, "our infrastructure was so antiquated it was taking us more than six months to deploy a new microservice. Today, a new microservice takes less than five days to deploy. And we’re working on getting it to an hour."
+  </div>
+</div>
+
+</section>
+
+
+<div class="banner2">
+  <div class="banner2text">
+      "We looked at a lot of different options, but Kubernetes really stood out....the fact that on day one it was designed to run on bare metal just as well as Google Cloud meant that we could actually migrate to it inside of our data centers, and then use those same tools and concepts to run across public cloud providers as&nbsp;well."<br><br><span style="font-size:15px;letter-spacing:0.08em">- SAM GHOUDS, CO-FOUNDER AND SERVICES ARCHITECT OF BOX</span>
+  </div>
+</div>
+
+
+<section class="section2">
+
+  <div class="fullcol">
+      <h2>In the summer of 2014, Box was feeling the pain of a decade’s worth of hardware and software infrastructure that wasn’t keeping up with the company’s needs.</h2>
+
+      A platform that allows its more than 50 million users (including governments and big businesses like <a href="https://www.ge.com/">General Electric</a>) to manage and share content in the cloud, Box was originally a <a href="http://php.net/">PHP</a> monolith of millions of lines of code built exclusively with bare metal inside of its own data centers. It had already begun to slowly chip away at the monolith, decomposing it into microservices. And "as we’ve been expanding into regions around the globe, and as the public cloud wars have been heating up, we’ve been focusing a lot more on figuring out how we run our workload across many different environments and many different cloud infrastructure providers," says Box Cofounder and Services Architect Sam Ghods. "It’s been a huge challenge thus far because all these different providers, especially bare metal, have very different interfaces and ways in which you work with them."<br><br>
+      Box’s cloud native journey accelerated that June, when Ghods attended <a href="https://www.docker.com/events/dockercon">DockerCon</a>. The company had come to the realization that it could no longer run its applications only off bare metal, and was researching containerizing with Docker, virtualizing with OpenStack, and supporting public cloud.<br><br>
+      At that conference, Google announced the release of its Kubernetes container management system, and Ghods was won over. "We looked at a lot of different options, but Kubernetes really stood out, especially because of the incredibly strong team of <a href="https://research.google.com/pubs/pub43438.html">Borg</a> veterans and the vision of having a completely infrastructure-agnostic way of being able to run cloud software," he says, referencing Google’s internal container orchestrator Borg. "The fact that on day one it was designed to run on bare metal just as well as <a href="https://cloud.google.com/">Google Cloud</a> meant that we could actually migrate to it inside of our data centers, and then use those same tools and concepts to run across public cloud providers as well."<br><br>
+      Another plus: Ghods liked that <a href="kubernetes.io">Kubernetes</a> has a universal set of API objects like pod, service, replica set and deployment object, which created a consistent surface to build tooling against. "Even PaaS layers like <a href="https://www.openshift.com/">OpenShift</a> or <a href="http://deis.io/">Deis</a> that build on top of Kubernetes still treat those objects as first-class principles," he says. "We were excited about having these abstractions shared across the entire ecosystem, which would result in a lot more momentum than we saw in other potential solutions."<br><br>
+      Box deployed Kubernetes in a cluster in a production data center just six months later. Kubernetes was then still pre-beta, on version 0.11. They started small: The very first thing Ghods’s team ran on Kubernetes was a Box API checker that confirms Box is up. "That was just to write and deploy some software to get the whole pipeline functioning," he says. Next came some daemons that process jobs, which was "nice and safe because if they experienced any interruptions, we wouldn’t fail synchronous incoming requests from customers."
+
+  </div>
+</section>
+
+<div class="banner3">
+  <div class="banner3text">
+    "As we’ve been expanding into regions around the globe, and as the public cloud wars have been heating up, we’ve been focusing a lot more on figuring out how we [can have Kubernetes help] run our workload across many different environments and many different cloud infrastructure providers."
+  </div>
+</div>
+
+<section class="section3">
+  <div class="fullcol">
+    The first live service, which the team could route to and ask for information, was launched a few months later. At that point, Ghods says, "We were comfortable with the stability of the Kubernetes cluster. We started to port some services over, then we would increase the cluster size and port a few more, and that’s ended up to about 100 servers in each data center that are dedicated purely to Kubernetes. And that’s going to be expanding a lot over the next 12 months, probably to many hundreds if not thousands."<br><br>
+    While observing teams who began to use Kubernetes for their microservices, "we immediately saw an uptick in the number of microservices being released," Ghods&nbsp;notes. "There was clearly a pent-up demand for a better way of building software through microservices, and the increase in agility helped our developers be more productive and make better architectural choices."
+    <br><br><div class="quote">"There was clearly a pent-up demand for a better way of building software through microservices, and the increase in agility helped our developers be more productive and make better architectural choices."</div><br>
+    Ghods reflects that as early adopters, Box had a different journey from what companies experience now. "We were definitely lock step with waiting for certain things to stabilize or features to get released," he says. "In the early days we were doing a lot of contributions [to components such as kubectl apply] and waiting for Kubernetes to release each of them, and then we’d upgrade, contribute more, and go back and forth several times. The entire project took about 18 months from our first real deployment on Kubernetes to having general availability. If we did that exact same thing today, it would probably be no more than six."<br><br>
+    In any case, Box didn’t have to make too many modifications to Kubernetes for it to work for the company. "The vast majority of the work our team has done to implement Kubernetes at Box has been making it work inside of our existing (and often legacy) infrastructure," says Ghods, "such as upgrading our base operating system from RHEL6 to RHEL7 or integrating it into <a href="https://www.nagios.org/">Nagios</a>, our monitoring infrastructure. But overall Kubernetes has been remarkably flexible with fitting into many of our constraints, and we’ve been running it very successfully on our bare metal infrastructure."<br><br>
+    Perhaps the bigger challenge for Box was a cultural one. "Kubernetes, and cloud native in general, represents a pretty big paradigm shift, and it’s not very incremental," Ghods says. "We’re essentially making this pitch that Kubernetes is going to solve everything because it does things the right way and everything is just suddenly better. But it’s important to keep in mind that it’s not nearly as proven as many other solutions out there. You can’t say how long this or that company took to do it because there just aren’t that many yet. Our team had to really fight for resources because our project was a bit of a moonshot."
+  </div>
+</section>
+
+  <div class="banner4">
+    <div class="banner4text">
+    "The vast majority of the work our team has done to implement Kubernetes at Box has been making it work inside of our existing [and often legacy] infrastructure....overall Kubernetes has been remarkably flexible with fitting into many of our constraints, and we’ve been running it very successfully on our bare metal infrastructure."
+    </div>
+  </div>
+
+<section class="section4">
+  <div class="fullcol">
+    Having learned from experience, Ghods offers these two pieces of advice for companies going through similar challenges:
+    <h2>1. Deliver early and often.</h2> Service discovery was a huge problem for Box, and the team had to decide whether to build an interim solution or wait for Kubernetes to natively satisfy Box’s unique requirements. After much debate, "we just started focusing on delivering something that works, and then dealing with potentially migrating to a more native solution later," Ghods says. "The above-all-else target for the team should always be to serve real production use cases on the infrastructure, no matter how trivial. This helps keep the momentum going both for the team itself and for the organizational perception of the project." </br></br>
+    <h2>2. Keep an open mind about what your company has to abstract away from developers and what it&nbsp;doesn’t.</h2> Early on, the team built an abstraction on top of Docker files to help ensure that images had the right security updates.
+    This turned out to be superfluous work, since container images are considered immutable and you can easily scan them post-build to ensure they do not contain vulnerabilities. Because managing infrastructure through containerization is such a discontinuous leap, it’s better to start by interacting directly with the native tools and learning their unique advantages and caveats. An abstraction should be built only after a practical need for it arises.</br></br>
+    In the end, the impact has been powerful. "Before Kubernetes," Ghods says, "our infrastructure was so antiquated it was taking us more than six months to deploy a new microservice. Now a new microservice takes less than five days to deploy. And we’re working on getting it to an hour. Granted, much of that six months was due to how broken our systems were, but bare metal is intrinsically a difficult platform to support unless you have a system like Kubernetes to help manage&nbsp;it."</br></br>
+    By Ghods’s estimate, Box is still several years away from his goal of being a 90-plus percent Kubernetes shop. "We’re very far along on having a mission-critical, stable Kubernetes deployment that provides a lot of value," he says. "Right now about five percent of all of our compute runs on Kubernetes, and I think in the next six months we’ll likely be between 20 to 50 percent. We’re working hard on enabling all stateless service use cases, and shift our focus to stateful services after&nbsp;that."
+  </div>
+</section>
+
+  <div class="banner5">
+    <div class="banner5text">
+    "Ghods predicts that Kubernetes has the opportunity to be the new cloud platform. '...because it’s a never-before-seen level of automation and intelligence surrounding infrastructure that is portable and agnostic to every way you can run your infrastructure.'"
+    </div>
+  </div>
+
+<section class="section5">
+  <div class="fullcol">
+    In fact, that’s what he envisions across the industry: Ghods predicts that Kubernetes has the opportunity to be the new cloud platform. Kubernetes provides an API consistent across different cloud platforms including bare metal, and "I don’t think people have seen the full potential of what’s possible when you can program against one single interface," he says. "The same way <a href="https://aws.amazon.com/">AWS</a> changed infrastructure so that you don’t have to think about servers or cabinets or networking equipment anymore, Kubernetes enables you to focus exclusively on the containers that you’re running, which is pretty exciting. That’s the vision."</br></br>
+    Ghods points to projects that are already in development or recently released for Kubernetes as a cloud platform: cluster federation, the Dashboard UI, and <a href="https://coreos.com/">CoreOS</a>’s etcd operator. "I honestly believe it’s the most exciting thing I’ve seen in cloud infrastructure," he says, "because it’s a never-before-seen level of automation and intelligence surrounding infrastructure that is portable and agnostic to every way you can run your infrastructure."</br></br>
+    Box, with its early decision to use bare metal, embarked on its Kubernetes journey out of necessity. But Ghods says that even if companies don’t have to be agnostic about cloud providers today, Kubernetes may soon become the industry standard, as more and more tooling and extensions are built around the API.</br></br>
+    "The same way it doesn’t make sense to deviate from Linux because it’s such a standard," Ghods says, "I think Kubernetes is going down the same path. It is still early days—the documentation still needs work and the user experience for writing and publishing specs to the Kubernetes clusters is still rough. When you’re on the cutting edge you can expect to bleed a little. But the bottom line is, this is where the industry is going. Three to five years from now it’s really going to be shocking if you run your infrastructure any other way."
+  </div>
+</section>
+
+</body>
+</html>
@@ -0,0 +1,138 @@
+---
+title: GolfNow Case Study
+layout: none
+class: gridPage
+cid: caseStudies
+---
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+      <link href="https://fonts.googleapis.com/css?family=Roboto:300,400" rel="stylesheet">
+      <link rel="stylesheet" type="text/css" href="/css/style_golfnow.css">
+    <title>GolfNow Case Study</title>
+  </head>
+<body>
+
+  <div class="banner1">
+    <h1>CASE STUDY: <img src="/images/golfnow_logo.png" class="logo" width="20%" style="margin-bottom:-6px"><br>
+    <div class="subhead">Saving Time and Money with Cloud Native Infrastructure</div>
+  </h1>
+</div>
+
+
+<div class="details">
+    Company&nbsp;<b>GolfNow</b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Location&nbsp;<b>Orlando, Florida</b>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Industry&nbsp;<b>Golf Industry Technology and Services Provider</b>
+</div>
+
+<hr>
+
+<section class="section1">
+  <div class="cols">
+    <div class="col1">
+
+    <h2>Challenge</h2>
+      A member of the <a href="http://www.nbcunicareers.com/our-businesses/nbc-sports-group">NBC Sports Group</a>, <a href="https://www.golfnow.com/">GolfNow</a> is the golf industry’s technology and services leader, managing 10 different products, as well as the largest e-commerce tee time marketplace in the world. As its business began expanding rapidly and globally, GolfNow’s monolithic application became problematic. "We kept growing our infrastructure vertically rather than horizontally, and the cost of doing business became problematic," says Sheriff Mohamed, GolfNow’s Director, Architecture. "We wanted the ability to more easily expand globally."
+      <br>
+  </div>
+
+  <div class="col2">
+    <h2>Solution</h2>
+      Turning to microservices and containerization, GolfNow began moving its applications and databases from third-party services to its own clusters running on <a href="https://www.docker.com/">Docker</a> and <a href="http://kubernetes.io/">Kubernetes.</a><br><br>
+
+    <h2>Impact</h2>
+      The results were immediate. While maintaining the same capacity—and beyond, during peak periods—GolfNow saw its infrastructure costs for the first application virtually cut in half.
+    </div>
+  </div>
+</section>
+
+
+<div class="banner2">
+  <div class="banner2text">
+      "With our growth we obviously needed to expand our infrastructure, and we kept growing vertically rather than horizontally. We were basically wasting money and doubling the cost of our infrastructure."<br><br><span style="font-size:15px;letter-spacing:0.08em">- SHERIFF MOHAMED, DIRECTOR, ARCHITECTURE AT GOLFNOW</span>
+  </div>
+</div>
+
+<section class="section2">
+  <div class="fullcol">
+      <h2>It’s not every day that you can say you’ve slashed an operating expense by half.</h2>
+
+      But Sheriff Mohamed and Josh Chandler did just that when they helped lead their company, <a href="https://www.golfnow.com/">GolfNow</a>, on a journey from a monolithic to a containerized, cloud native infrastructure managed by Kubernetes.
+      <br> <br>
+      A top-performing business within the NBC Sports Group, GolfNow is a technology and services company with the largest tee time marketplace in the world. GolfNow serves 5 million active golfers across 10 different products. In recent years, the business had grown so fast that the infrastructure supporting their giant monolithic application (written in C#.NET and backed by SQL Server database management system) could not keep up. "With our growth we obviously needed to expand our infrastructure, and we kept growing vertically rather than horizontally," says Sheriff, GolfNow’s Director, Architecture. "Our costs were growing exponentially. And on top of that, we had to build a Disaster Recovery (DR) environment, which then meant we’d have to copy exactly what we had in our original data center to another data center that was just the standby. We were basically wasting money and doubling the cost of our infrastructure."
+      <br> <br>
+      In moving just the first of GolfNow’s important applications—a booking engine for golf courses and B2B marketing platform—from third-party services to their own Kubernetes environment, "our bill went down drastically," says Sheriff.
+      <br> <br>
+      The path to those stellar results began in late 2014. In order to support GolfNow’s global growth, the team decided that the company needed to have multiple data centers and the ability to quickly and easily re-route traffic as needed. "From there we knew that we needed to go in a direction of breaking things apart, microservices, and containerization," says Sheriff. "At the time we were trying to get away from <a href="https://www.microsoft.com/net">C#.NET</a> and <a href="https://www.microsoft.com/en-cy/sql-server/sql-server-2016">SQL Server</a> since it didn’t run very well on Linux, where everything container was running smoothly."
+      <br> <br>
+      To that end, the team shifted to working with <a href="https://nodejs.org/">Node.js</a>, the open-source, cross-platform JavaScript runtime environment for developing tools and applications, and <a href="https://www.mongodb.com/">MongoDB</a>, the open-source database program. At the time, <ahref="https://www.docker.com/">Docker</a>, the platform for deploying applications in containers, was still new. But once the team began experimenting with it, Sheriff says, "we realized that was the way we wanted to go, especially since that’s the way the industry is heading."
+  </div>
+</section>
+
+<div class="banner3">
+  <div class="banner3text">
+    "The team migrated the rest of the application into their Kubernetes cluster. And the impact was immediate: On top of cutting monthly costs by a large percentage, says Sheriff, 'Running at the same capacity and during our peak time, we were able to horizontally grow. Since we were using our VMs more efficiently with containers, we didn’t have to pay extra money at all.'"
+  </div>
+</div>
+
+<section class="section3">
+  <div class="fullcol">
+    GolfNow’s dev team ran an "internal, low-key" proof of concept and were won over. "We really liked how easy it was to be able to pass containers around to each other and have them up and running in no time, exactly the way it was running on my machine," says Sheriff. "Because that is always the biggest gripe that Ops has with developers, right? ‘It worked on my machine!’ But then we started getting to the point of, ‘How do we make sure that these things stay up and running?’" <br><br>
+    That led the team on a quest to find the right orchestration system for the company’s needs. Sheriff says the first few options they tried were either too heavy or "didn’t feel quite right." In late summer 2015, they discovered the just-released <a href="http://kubernetes.io/">Kubernetes</a>, which Sheriff immediately liked for its ease of use. "We did another proof of concept," he says, "and Kubernetes won because of the fact that the community backing was there, built on top of what Google had already done."
+    <br><br>
+    But before they could go with Kubernetes, <a href="http://www.nbc.com/">NBC</a>, GolfNow’s parent company, also asked them to comparison shop with another company. Sheriff and his team liked the competing company’s platform user interface, but didn’t like that its platform would not allow containers to run natively on Docker. With no clear decision in sight, Sheriff’s VP at GolfNow, Steve McElwee, set up a three-month trial during which a GolfNow team (consisting of Sheriff and Josh, who’s now Lead Architect, Open Platforms) would build out a Kubernetes environment, and a large NBC team would build out one with the other company’s platform.
+    <br><br>
+    "We spun up the cluster and we tried to get everything to run the way we wanted it to run," Sheriff says. "The biggest thing that we took away from it is that not only did we want our applications to run within Kubernetes and Docker, we also wanted our databases to run there. We literally wanted our entire infrastructure to run within Kubernetes."
+    <br><br>
+    At the time there was nothing in the community to help them get Kafka and MongoDB clusters running within a Kubernetes and Docker environment, so Sheriff and Josh figured it out on their own, taking a full month to get it right. "Everything started rolling from there," Sheriff says. "We were able to get all our applications connected, and we finished our side of the proof of concept a month in advance. My VP was like, ‘Alright, it’s over. Kubernetes wins.’"
+    <br><br>
+    The next step, beginning in January 2016, was getting everything working in production. The team focused first on one application that was already written in Node.js and MongoDB. A booking engine for golf courses and B2B marketing platform, the application was already going in the microservice direction but wasn’t quite finished yet. At the time, it was running in <a href="https://devcenter.heroku.com/articles/mongohq">Heroku Compose</a> and other third-party services—resulting in a large monthly bill.
+
+  </div>
+</section>
+
+  <div class="banner4">
+    <div class="banner4text">
+    "'The time I spent actually moving the applications was under 30 seconds! We can move data centers in just incredible amounts of time. If you haven’t come from the Kubernetes world you wouldn’t believe me.' Sheriff puts it in these terms: 'Before Kubernetes I wasn’t sleeping at night, literally. I was woken up all the time, because things were down. After Kubernetes, I’ve been sleeping at night.'"
+    </div>
+  </div>
+
+<section class="section4">
+  <div class="fullcol">
+    "The goal was to take all of that out and put it within this new platform we’ve created with Kubernetes on <a href="https://cloud.google.com/compute/">Google Compute Engine (GCE)</a>," says Sheriff. "So we ended up building piece by piece, in parallel, what was out in Heroku and Compose, in our Kubernetes cluster. Then, literally, just switched configs in the background. So in Heroku we had the app running hitting a Compose database. We’d take the config, change it and make it hit the database that was running in our cluster."
+    <br><br>
+    Using this procedure, they were able to migrate piecemeal, without any downtime. The first migration was done during off hours, but to test the limits, the team migrated the second database in the middle of the day, when lots of users were running the application. "We did it," Sheriff says, "and again it was successful. Nobody noticed."
+    <br><br>
+    After three weeks of monitoring to make sure everything was running stable, the team migrated the rest of the application into their Kubernetes cluster. And the impact was immediate: On top of cutting monthly costs by a large percentage, says Sheriff, "Running at the same capacity and during our peak time, we were able to horizontally grow. Since we were using our VMs more efficiently with containers, we didn’t have to pay extra money at all."
+    <br><br>
+    Not only were they saving money, but they were also saving time. "I had a meeting this morning about migrating some applications from one cluster to another," says Josh. "I spent about 2 hours explaining the process. The time I spent actually moving the applications was under 30 seconds! We can move data centers in just incredible amounts of time. If you haven’t come from the Kubernetes world you wouldn’t believe me." Sheriff puts it in these terms: "Before Kubernetes I wasn’t sleeping at night, literally. I was woken up all the time, because things were down. After Kubernetes, I’ve been sleeping at night."
+    <br><br>
+    A small percentage of the applications on GolfNow have been migrated over to the Kubernetes environment. "Our Core Team is rewriting a lot of the .NET applications into <a href="https://www.microsoft.com/net/core">.NET Core</a> [which is compatible with Linux and Docker] so that we can run them within containers," says Sheriff.
+    <br><br>
+    Looking ahead, Sheriff and his team want to spend 2017 continuing to build a whole platform around Kubernetes with <a href="https://github.com/drone/drone">Drone</a>, an open-source continuous delivery platform, to make it more developer-centric. "Now they’re able to manage configuration, they’re able to manage their deployments and things like that, making all these subteams that are now creating all these microservices, be self sufficient," he says. "So it can pull us away from applications and allow us to just make sure the cluster is running and healthy, and then actually migrate that over to our Ops team."
+
+  </div>
+</section>
+
+  <div class="banner5">
+    <div class="banner5text">
+    "Having gone from complete newbies to production-ready in three months, the GolfNow team is eager to encourage other companies to follow their lead. 'This is The Six Million Dollar Man of the cloud right now,' adds Josh. 'Just try it out, watch it happen. I feel like the proof is in the pudding when you look at these kinds of application stacks. They’re faster, they’re more resilient.'"
+    </div>
+  </div>
+
+<section class="section5">
+  <div class="fullcol">
+    And long-term, Sheriff has an even bigger goal for getting more people into the Kubernetes fold. "We’re actually trying to make this platform generic enough so that any of our sister companies can use it if they wish," he says. "Most definitely I think it can be used as a model. I think the way we migrated into it, the way we built it out, are all ways that I think other companies can learn from, and should not be afraid of."
+    <br><br>
+    The GolfNow team is also giving back to the Kubernetes community by open-sourcing a bot framework that Josh built. "We noticed that the dashboard user interface is actually moving a lot faster than when we started," says Sheriff. "However we realized what we needed was something that’s more of a bot that really helps us administer Kubernetes as a whole through Slack." Josh explains: "With the Kubernetes-Slack integration, you can essentially hook into a cluster and the issue commands and edit configurations. We’ve tried to simplify the security configuration as much as possible. We hope this will be our major thank you to Kubernetes, for everything you’ve given us."
+    <br><br>
+    Having gone from complete newbies to production-ready in three months, the GolfNow team is eager to encourage other companies to follow their lead. The lessons they’ve learned: "You’ve got to have buy-in from your boss," says Sheriff. "Another big deal is having two to three people dedicated to this type of endeavor. You can’t have people who are half in, half out." And if you don’t have buy-in from the get go, proving it out will get you there.
+    <br><br>
+    "This is The Six Million Dollar Man of the cloud right now," adds Josh. "Just try it out, watch it happen. I feel like the proof is in the pudding when you look at these kinds of application stacks. They’re faster, they’re more resilient."
+
+  </div>
+</section>
+
+</body>
+</html>
@@ -14,17 +14,23 @@ cid: caseStudies
    <main>
        <div class="content">
            <div class="case-studies">
+              <div class="case-study">
+                  <img src="/images/case_studies/golfnow.png" alt="GolfNow">
+                  <p class="quote">"We can move data centers in incredible amounts of time. If you haven’t come from the Kubernetes world and I tell you this is what I’ve been doing, you wouldn’t believe me."</p>
+                  <!--<p class="attrib">— Josh Chandler, Lead Architect, Open Platforms at GolfNow</p>-->
+                  <a href="/case-studies/golfnow/">Read about GolfNow</a>
+              </div>
                <div class="case-study">
                    <img src="/images/case_studies/pearson.png" alt="Pearson">
                    <p class="quote">"We chose Kubernetes because of its flexibility, ease of management and the way it improves our engineers' productivity."</p>
                    <!--<p class="attrib">— Chris Jackson, Director for Cloud Product Engineering, Pearson</p>-->
-                    <a href="./pearson/">Read about Pearson</a>
+                    <a href="/case-studies/pearson/">Read about Pearson</a>
                </div>
                <div class="case-study">
                    <img src="/images/case_studies/wikimedia.png" alt="Wikimedia">
                    <p class="quote">"With Kubernetes, we're simplifying our environment and making it easier for developers to build the tools that make wikis run better."</p>
                    <!--<p class="attrib">— Yuvi Panda, Operations Engineer, Wikimedia Foundation</p>-->
-                    <a href="./wikimedia/">Read about Wikimedia</a>
+                    <a href="/case-studies/wikimedia/">Read about Wikimedia</a>
                </div>
                <div class="case-study">
                    <img src="/images/case_studies/ebay.png" alt="eBay">
@@ -33,8 +39,8 @@ cid: caseStudies
                </div>
                <div class="case-study">
                    <img src="/images/case_studies/box.png" alt="box">
-                    <p class="quote">Kubernetes at Box: Microservices at Maximum Velocity</p>
-                    <a href="https://blog.box.com/blog/kubernetes-box-microservices-maximum-velocity/">Read about Box</a>
+                    <p class="quote">"Kubernetes has the opportunity to be the new cloud platform. Because it’s a never-before-seen level of automation and intelligence surrounding infrastructure that is portable and agnostic to every way you can run your infrastructure."</p>
+                    <a href="/case-studies/box/">Read about Box</a>
                </div>
            </div>
        </div>
@@ -82,8 +88,8 @@ cid: caseStudies
            <a target="_blank" href="https://cloud.google.com/customers/philips/"><img src="/images/case_studies/philips_logo.png" alt="Philips"></a>
            <a target="_blank" href="https://youtu.be/EC_ZRLsw58M"><img src="/images/case_studies/buffer_logo.png" alt="buffer"></a>
            <a target="_blank" href="https://youtu.be/lmeFkH-rHII"><img src="/images/case_studies/comcast_logo.png" alt="Comcast"></a>
-            <a href="./wikimedia/"><img src="/images/case_studies/wikimedia_logo.png" alt="Wikimedia"></a>
-            <a href="./pearson/"><img src="/images/case_studies/pearson_logo.png" alt="Pearson"></a>
+            <a href="/case-studies/wikimedia/"><img src="/images/case_studies/wikimedia_logo.png" alt="Wikimedia"></a>
+            <a href="/case-studies/pearson/"><img src="/images/case_studies/pearson_logo.png" alt="Pearson"></a>
            <a target="_blank" href="#" onclick="event.preventDefault(); kub.showVideo()"><img src="/images/case_studies/zulily_logo.png" alt="zulily"></a>
            <a target="_blank" href="http://www.nextplatform.com/2015/11/12/inside-ebays-shift-to-kubernetes-and-containers-atop-openstack/"><img src="/images/case_studies/ebay_logo.png" alt="Ebay"></a>
            <a target="_blank" href="https://docs.google.com/a/google.com/forms/d/e/1FAIpQLScuI7Ye3VQHQTwBASrgkjQDSS5TP0g3AXfFhwSM9YpHgxRKFA/viewform" class="tell-your-story"><img src="/images/case_studies/story.png" alt="Tell your story"></a>
@@ -5,14 +5,14 @@ assignees:
 title: 认识 Kubernetes?
 ---

-Kubernetes 是一个 [开源的容器调度平台，它可以自动化应用容器的部署、扩展和操作](http://www.slideshare.net/BrianGrant11/wso2con-us-2015-kubernetes-a-platform-for-automating-deployment-scaling-and-operations) 可以跨主机集群, 提供以容器为中心的基础架构。
+Kubernetes 是一个跨主机集群的 [开源的容器调度平台，它可以自动化应用容器的部署、扩展和操作](http://www.slideshare.net/BrianGrant11/wso2con-us-2015-kubernetes-a-platform-for-automating-deployment-scaling-and-operations) , 提供以容器为中心的基础架构。

 使用 Kubernetes, 您可以快速高效地响应客户需求:

 - 快速、可预测地部署您的应用程序
 - 拥有即时扩展应用程序的能力
- - 不影响现有业务的情况下，无缝地发布新功能。
- - 优化您的硬件资源，降低您的拥有成本
+ - 不影响现有业务的情况下，无缝地发布新功能
+ - 优化硬件资源，降低成本

 我们的目标是构建一个软件和工具的生态系统，以减轻您在公共云或私有云运行应用程序的负担。

@@ -36,11 +36,11 @@ Kubernetes 项目由 Google 公司在 2014 年启动。Kubernetes 建立在 [Goo

 *新方式* 是基于操作系统级虚拟化而不是硬件级虚拟化方法来部署容器。容器之间彼此隔离并与主机隔离：它们具有自己的文件系统，不能看到彼此的进程，并且它们所使用的计算资源是可以被限制的。它们比虚拟机更容易构建，并且因为它们与底层基础架构和主机文件系统隔离，所以它们可以跨云和操作系统快速分发。

-由于容器体积小且启动快，因此可以在每个容器镜像中打包一个应用程序。这种一对一的应用镜像关系拥有很多好处。使用容器，不需要与外部的基础架构环境绑定, 因为每一个应用程序不需要外部依赖，更不需要与外部的基础架构环境依赖。完美解决了从开发到生产环境的一致性问题。
+由于容器体积小且启动快，因此可以在每个容器镜像中打包一个应用程序。这种一对一的应用镜像关系拥有很多好处。使用容器，不需要与外部的基础架构环境绑定, 因为每一个应用程序都不需要外部依赖，更不需要与外部的基础架构环境依赖。完美解决了从开发到生产环境的一致性问题。

-类似地，容器比虚拟机更加透明，这有助于监测和管理。真实的情况是，容器进程的生命周期由基础设施管理，而容器内的进程对外是隐藏的。最后，每个应用程序用容器封装，管理容器部署就等同于管理应用程序部署。
+容器同样比虚拟机更加透明，这有助于监测和管理。尤其是容器进程的生命周期由基础设施管理，而不是由容器内的进程对外隐藏时更是如此。最后，每个应用程序用容器封装，管理容器部署就等同于管理应用程序部署。

-容器好处摘要:
+容器优点摘要:

 * **敏捷的应用程序创建和部署**:
    与虚拟机镜像相比，容器镜像更容易创建，提升了硬件的使用效率。
@@ -55,7 +55,7 @@ Kubernetes 项目由 Google 公司在 2014 年启动。Kubernetes 建立在 [Goo
 * **以应用为中心的管理**:
    提升了操作系统的抽象级别，以便在使用逻辑资源的操作系统上运行应用程序。
 * **松耦合、分布式、弹性伸缩 [微服务](http://martinfowler.com/articles/microservices.html)**:
-    应用程序被分成更小，更独立的部分，可以动态部署和管理 - 而不是巨型单体应用运行在专用的大型机。
+    应用程序被分成更小，更独立的部分，可以动态部署和管理 - 而不是巨型单体应用运行在专用的大型机上。
 * **资源隔离**:
    通过对应用进行资源隔离，可以很容易的预测应用程序性能。
 * **资源利用**:
@@ -87,11 +87,11 @@ Kubernetes 满足了生产中运行应用程序的许多常见的需求，例如

 #### 为什么 Kubernetes 是一个平台?

-Kubernetes 提供了很多的功能，总会有新的场景会受益于新特性。它可以简化应用程序的工作流，加快开发速度。被大家认可的应用编排通常需要有较强的自动化能力。这就是为什么 Kubernetes 被设计作为构建组件和工具的生态系统平台，以便更轻松地部署、扩展和管理应用程序。
+Kubernetes 提供了很多的功能，总会有新的场景受益于新特性。它可以简化应用程序的工作流，加快开发速度。被大家认可的应用编排通常需要有较强的自动化能力。这就是为什么 Kubernetes 被设计作为构建组件和工具的生态系统平台，以便更轻松地部署、扩展和管理应用程序。

 [Label](/docs/user-guide/labels/) 允许用户按照自己的方式组织管理对应的资源。 [注解](/docs/user-guide/annotations/) 使用户能够以自定义的描述信息来修饰资源，以适用于自己的工作流，并为管理工具提供检查点状态的简单方法。

-此外，[Kubernetes 控制面](/docs/admin/cluster-components) 是构建在相同的 [APIs](/docs/api/) 上面，开发员人和用户都可以用。用户可以编写自己的控制器， [调度器](https://git.k8s.io/community/contributors/devel/scheduler.md)等等，如果这么做，根据新加的[自定义 API](https://git.k8s.io/community/contributors/design-proposals/extending-api.md) ，可以扩展当前的通用 [CLI 命令行工具](/docs/user-guide/kubectl-overview/)。
+此外，[Kubernetes 控制面 (Controll Plane)](/docs/admin/cluster-components) 是构建在相同的 [APIs](/docs/api/) 上面，开发人员和用户都可以用。用户可以编写自己的控制器， [调度器](https://github.com/kubernetes/kubernetes/tree/{{page.githubbranch}}/docs/devel/scheduler.md)等等，如果这么做，根据新加的[自定义 API](https://github.com/kubernetes/kubernetes/blob/{{page.githubbranch}}/docs/design/extending-api.md) ，可以扩展当前的通用 [CLI 命令行工具](/docs/user-guide/kubectl-overview/)。

 这种 [设计](https://git.k8s.io/community/contributors/design-proposals/principles.md) 使得许多其他系统可以构建在 Kubernetes 之上。

@@ -116,4 +116,3 @@ Kubernetes 不是一个传统意义上，包罗万象的 PaaS (平台即服务)
 #### *Kubernetes* 是什么意思? K8s?

 名称 **Kubernetes** 源于希腊语，意为 "舵手" 或 "飞行员"， 且是英文 "governor" 和 ["cybernetic"](http://www.etymonline.com/index.php?term=cybernetics)的词根。 **K8s** 是通过将 8 个字母 "ubernete" 替换为 8 而导出的缩写。另外，在中文里，k8s 的发音与 Kubernetes 的发音比较接近。
-
@@ -1,5 +1,5 @@
 ---
-title: 交互式教程 - 创建集群
+title: 互动教程 - 创建集群
 ---

 <!DOCTYPE html>
@@ -31,12 +31,12 @@ title: 使用 Minikube 创建一个集群
 			<div class="col-md-8">
 				<h3>Kubernetes 集群</h3>
 				<p>
-				<b>Kubernetes 用于协调高度可用的计算机集群，这些计算机群集被连接作为单个单元工作。</b> Kubernetes 中的抽象允许您将容器化的应用程序部署到集群，而不必专门将其绑定到单个计算机。为了利用这种新的部署模型，应用程序需要以将它们与各个主机分离的方式打包: 它们需要被容器化。容器化应用程序比过去的部署模型更灵活和可用，其中应用程序直接安装到特定机器上，作为深入集成到主机中的软件包。 <b>Kubernetes 以更有效的方式自动化、跨集群的容器应用程序的分发和调度。</b> Kubernetes 是一个 <a href="https://github.com/kubernetes/kubernetes">开源</a> 平台，为生产环境准备的。
+				<b>Kubernetes 用于协调高度可用的计算机集群，这些计算机群集被连接作为单个单元工作。</b> Kubernetes 的抽象性允许您将容器化的应用程序部署到集群，而不必专门将其绑定到单个计算机。为了利用这种新的部署模型，应用程序需要以将它们与各个主机分离的方式打包: 它们需要被容器化。容器化应用程序比过去的部署模型更灵活和可用，其中应用程序直接安装到特定机器上，作为深入集成到主机中的软件包。 <b>Kubernetes 在一个集群上以更有效的方式自动分发和调度容器应用程序。</b> Kubernetes 是一个 <a href="https://github.com/kubernetes/kubernetes">开源</a> 平台，可满足生产环境的需要。
 				</p>
 				<p>Kubernetes 集群由两种类型的资源组成:
 					<ul>
-			            <li>一个 <b>Master</b> 调度节点</li>
-			            <li><b>Nodes</b> 应用程序实际运行的地方</li>
+			            <li>一个 <b>Master</b> 是集群的调度节点</li>
+			            <li><b>Nodes</b> 是应用程序实际运行的工作节点</li>
 			        </ul>
 			    </p>
 			</div>
@@ -74,21 +74,21 @@ title: 使用 Minikube 创建一个集群
 		<div class="row">
 			<div class="col-md-8">
 				<p><b>Master 负责管理集群。</b> master 协调集群中的所有活动，例如调度应用程序、维护应用程序的所需状态、扩展应用程序和滚动更新。</p>
-				<p><b>node 是 Kubernetes 集群中的工作机器，可以是物理机或虚拟机。</b> 每个工作节点都有一个 Kubelet，它是管理 node 并与 Kubernetes Master 节点进行通信的代理。node 上还应具有处理容器操作的工作，例如 <a href="https://www.docker.com/">Docker</a> 或 <a href="https://coreos.com/rkt/">rkt</a>。一个 Kubernetes 工作集群至少有三个 node 节点。</p>
+				<p><b>节点 是 Kubernetes 集群中的工作机器，可以是物理机或虚拟机。</b> 每个工作节点都有一个 Kubelet，它是管理 节点 并与 Kubernetes Master 节点进行通信的代理。节点 上还应具有处理容器操作的工作，例如 <a href="https://www.docker.com/">Docker</a> 或 <a href="https://coreos.com/rkt/">rkt</a>。一个 Kubernetes 工作集群至少有三个节点。</p>

 			</div>
 			<div class="col-md-4">
 				<div class="content__box content__box_fill">
-					<p><i> Master 管理集群和 Nodes 用于托管正在运行的应用程序。  </i></p>
+					<p><i> Master 管理集群，而 节点 用于托管正在运行的应用程序。  </i></p>
 				</div>
 			</div>
 		</div>

 		<div class="row">
 			<div class="col-md-8">
-				<p>当您在 Kubernetes 上部署应用程序时，您可以告诉 master 启动应用程序容器。Master 调度容器在集群的 Node 上运行。<b> Nodes 使用 Master 公开的 Kubernetes API 与 Master 通信</b>。最终用户还可以直接使用 Kubernetes 的 API 与集群交互。</p>
+				<p>当您在 Kubernetes 上部署应用程序时，您可以告诉 master 启动应用程序容器。Master 调度容器在集群的 节点 上运行。<b> 节点 使用 Master 公开的 Kubernetes API 与 Master 通信</b>。最终用户还可以直接使用 Kubernetes 的 API 与集群交互。</p>

-				<p>Kubernetes 集群可以部署在物理机或虚拟机上。要开始使用 Kubernetes 开发，您可以使用 <a href="https://github.com/kubernetes/minikube">Minikube</a>。Minikube 是一个轻量级的 Kubernetes 实现，在本机创建一台虚拟机，并部署一个只包含一个节点的简单集群。 Minikube 适用于 Linux, Mac OS 和 Windows 系统。Minikube CLI 提供了集群的基本引导操作，包括启动、停止、状态和删除。但是，对于此基础训练，您将使用预先安装了 Minikube 的在线终端。</p>
+				<p>Kubernetes 集群可以部署在物理机或虚拟机上。要开始使用 Kubernetes 开发，您可以使用 <a href="https://github.com/kubernetes/minikube">Minikube</a>。Minikube 是一个轻量级的 Kubernetes 实现，会在本机创建一台虚拟机，并部署一个只包含一个节点的简单集群。 Minikube 适用于 Linux, Mac OS 和 Windows 系统。Minikube CLI 提供了集群的基本引导操作，包括启动、停止、状态和删除。为了完成此基础训练，您将使用预先安装了 Minikube 的在线终端。</p>

 				<p>现在您已经知道 Kubernetes 是什么，让我们使用在线教程，开始我们的第一个集群!</p>

@@ -98,7 +98,7 @@ title: 使用 Minikube 创建一个集群

 		<div class="row">
 			<div class="col-md-12">
-				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/cluster-interactive/" role="button">启动交互教程 <span class="btn__next">›</span></a>
+				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/cluster-interactive/" role="button">启动互动教程 <span class="btn__next">›</span></a>
 			</div>
 		</div>

@@ -1,5 +1,5 @@
 ---
-title: 交互式教程 - 部署应用程序
+title: 互动教程 - 部署应用程序
 ---

 <!DOCTYPE html>
@@ -30,9 +30,9 @@ title: 使用 kubectl 创建部署
 				一旦运行了 Kubernetes 集群，您可以在其上部署容器化应用程序。为此，您可以创建一个 Kubernetes <b>Deployment</b>。Deployment 负责创建和更新应用程序实例。创建 Deployment 后， Kubernetes master 会将 Deployment 创建的应用程序实例调度到集群中的各个节点。
 				</p>

-				<p>创建应用程序实例后，Kubernetes Deployment 控制器会持续监视这些实例。如果托管它的节点不可用或删除，则 Deployment 控制器将替换实例。 <b>这提供了一种解决机器故障或维护的自愈机制。</b></p>
+				<p>创建应用程序实例后，Kubernetes 部署控制器会持续监视这些实例。如果托管它的节点不可用或删除，则部署控制器将替换实例。 <b>这提供了一种解决机器故障或维护的自愈机制。</b></p>

-				<p>在编排前的世界中，通常会使用安装脚本启动应用程序，但是它们并不能从机器故障中恢复。通过创建应用程序实例并使其运行在跨节点的机器之间，Kubernetes Deployments 提供了截然不同的应用管理方法。 </p>
+				<p>在编排诞生前的世界中，通常会使用安装脚本启动应用程序，但是它们并不能从机器故障中恢复。通过创建应用程序实例并使其运行在跨节点的机器之间，Kubernetes 部署提供了截然不同的应用管理方法。 </p>

 			</div>

@@ -40,13 +40,13 @@ title: 使用 kubectl 创建部署
 				<div class="content__box content__box_lined">
 					<h3>概要:</h3>
 					<ul>
-						<li>Deployments</li>
+						<li>部署</li>
 						<li>Kubectl</li>
 					</ul>
 				</div>
 				<div class="content__box content__box_fill">
 					<p><i>
-						Deployment 负责创建和更新应用程序的实例
+						部署负责创建和更新应用程序的实例
 					</i></p>
 				</div>
 			</div>
@@ -69,9 +69,9 @@ title: 使用 kubectl 创建部署
 		<div class="row">
 			<div class="col-md-8">

-                <p>您可以使用 Kubernetes 命令行工具 <b>Kubectl</b>创建和管理 Deployment。Kubectl 使用 Kubernetes API 与集群进行交互。在本模块中，您将学习在 Kubernetes 集群上运行应用程序部署所需的最常见 Kubectl 命令。</p>
+                <p>您可以使用 Kubernetes 命令行工具 <b>Kubectl</b>创建和管理部署。Kubectl 使用 Kubernetes API 与集群进行交互。在本模块中，您将学习在 Kubernetes 集群上运行应用程序部署所需的最常见的 Kubectl 命令。</p>

-				<p>创建部署时，您需要为应用程序指定容器镜像以及要运行的副本数。您可以稍后通过更新部署来更改该信息；模块 <a href="/docs/tutorials/kubernetes-basics/scale-intro/">5</a> 和 <a href="/docs/tutorials/kubernetes-basics/update-intro/">6</a> 是一个基础训练讨论如何扩展和更新您的部署。</p>
+				<p>创建部署时，您需要为应用程序指定容器镜像以及要运行的副本数。您可以稍后通过更新部署来更改该信息；基础训练模块 <a href="/docs/tutorials/kubernetes-basics/scale-intro/">5</a> 和 <a href="/docs/tutorials/kubernetes-basics/update-intro/">6</a> 讨论如何扩展和更新您的部署。</p>



@@ -86,7 +86,7 @@ title: 使用 kubectl 创建部署

 		<div class="row">
 			<div class="col-md-8">
-				<p>对于我们的第一个部署，我们将使用 <a href="https://nodejs.org">Node.js</a> 应用程序打包到 Docker 容器。源代码和 Dockerfile 可在 Kubernetes Bootcamp <a href="https://github.com/kubernetes/kubernetes-bootcamp">GitHub 存储库</a> 中找到。</p>
+				<p>对于我们的第一个部署，我们将使用 <a href="https://nodejs.org">Node.js</a> 应用程序打包到 Docker 容器。源代码和 Dockerfile 可在 Kubernetes Bootcamp 的 <a href="https://github.com/kubernetes/kubernetes-bootcamp">GitHub 存储库</a> 中找到。</p>

 				<p>现在您已经知道部署是什么，我来再来看看在线教程，并部署我们的第一个应用程序!</p>

@@ -96,7 +96,7 @@ title: 使用 kubectl 创建部署

 		<div class="row">
 			<div class="col-md-12">
-				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/deploy-interactive/" role="button">启动交互式教程 <span class="btn__next">›</span></a>
+				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/deploy-interactive/" role="button">启动互动教程 <span class="btn__next">›</span></a>
 			</div>
 		</div>

@@ -1,5 +1,5 @@
 ---
-title: 交互式教程 - 应用程序探索
+title: 互动教程 - 应用程序探索
 ---

 <!DOCTYPE html>
@@ -1,5 +1,5 @@
 ---
-title: 查看 Pods 和 Nodes
+title: 查看 Pods 和节点
 ---

 <!DOCTYPE html>
@@ -22,7 +22,7 @@ title: 查看 Pods 和 Nodes
 				<ul>
 					<li>了解 Kubernetes Pods</li>
 					<li>了解 Kubernetes Nodes</li>
-					<li>已部署应用故障排除</li>
+					<li>已部署应用的故障排除</li>
 				</ul>
 			</div>

@@ -34,9 +34,9 @@ title: 查看 Pods 和 Nodes
 					<li>网络，作为唯一的集群 IP 地址</li>
 					<li>每个容器如何运行的信息，例如容器镜像版本或要使用的特定端口</li>
 				</ul>
-				<p>Pod 模型可以理解为应用程序特定的 "逻辑主机"，并且可以包含相对紧密耦合的不同应用程序容器。例如，Pod 可能包含带有 Node.js 应用程序的容器以及用于提供要由 Node.js Web 服务器发布数据的不同容器。Pod 中的容器共享 IP 地址和端口空间，始终位于同一位置并且统一调度，并在相同的节点上运行，共享上下文环境。</p>
+				<p>Pod 模型可以理解为应用程序特定的 "逻辑主机"，并且可以包含相对紧密耦合的不同应用程序容器。例如，Pod 可能包含带有 Node.js 应用程序的容器以及另一个要吸收 Node.js Web 服务器提供的数据的不同容器。Pod 中的容器共享 IP 地址和端口空间，始终位于同一位置并且统一调度，并在相同的节点上运行，共享上下文环境。</p>

-			<p>Pods 是 Kubernetes 平台上的原子单元。当我们在 Kubernetes 上创建一个部署时，该部署将在其中创建包含容器的 Pod (而不是直接创建容器)。每个 Pod 绑定到它被调度的节点，并且保持在那里，直到终止 (根据重启策略) 或删除。在节点故障的情况下，在集群中的其他可用节点上调度相同的 Pod。</p>
+			<p>Pods 是 Kubernetes 平台上原子级别的单元。当我们在 Kubernetes 上创建一个部署时，该部署将在其中创建包含容器的 Pod (而不是直接创建容器)。每个 Pod 都绑定到它被调度的节点，并且始终在那里，直到终止 (根据重启策略) 或删除。在节点故障的情况下，在集群中的其他可用节点上调度相同的 Pod。</p>

 			</div>
 			<div class="col-md-4">
@@ -44,13 +44,13 @@ title: 查看 Pods 和 Nodes
 					<h3>概要:</h3>
 					<ul>
 						<li>Pods</li>
-						<li>Nodes</li>
+						<li>节点</li>
 						<li>Kubectl 主要命令</li>
 					</ul>
 				</div>
 				<div class="content__box content__box_fill">
 						<p><i>
-							Pod 是一组或多个应用程序容器 (例如 Docker 或 rkt)，包含共享存储 (卷)，IP 地址以及有关如何运行它们的信息。
+							Pod是由一个或者多个应用程序容器构成的(例如 Docker 或 rkt)，包含共享存储 (卷)，IP 地址以及有关如何运行它们的信息。
 						</i></p>
 				</div>
 			</div>
@@ -72,19 +72,19 @@ title: 查看 Pods 和 Nodes

 		<div class="row">
 			<div class="col-md-8">
-				<h2>Nodes</h2>
-				<p>Pod 总是运行在 <b>Node</b>上。Node 是 Kubernetes 的工作机器，可以是一个虚拟机或物理，这取决于在集群的安装情况。每个 Node 由 Master 管理。一个 Node 上可以有多个 Pod, Kubernetes master 会自动处理调度集群各个 Node 上的 Pod。 Master 在自动调度时，会考虑每个 Node 上的可用资源。</p>
+				<h2>节点</h2>
+				<p>Pod 总是运行在 <b>Node</b>上。Node 是 Kubernetes 的工作机器，可以是虚拟机或物理机，这取决于在集群的安装情况。每个节点由 Master 管理。一个节点上可以有多个 Pod, Kubernetes master 会自动处理调度集群各个节点上的 Pod。 Master 在自动调度时，会考虑每个 Node 上的可用资源。</p>

-				<p>每个 Kubernetes Node 节点至少运行以下组件:</p>
+				<p>每个 Kubernetes 节点至少运行以下组件:</p>
 				<ul>
-					<li>Kubelet 是负责 Kubernetes Master 和 所有 Node 节点之间通信的进程，它管理机器上运行的 Pod 和容器。</li>
+					<li>Kubelet 是负责 Kubernetes Master 和 所有节点之间通信的进程，它管理机器上运行的 Pod 和容器。</li>
 					<li>容器运行时(例如 Docker, rkt) 负责从镜像仓库中拉取容器镜像，解包容器并运行应用程序。</li>
 				</ul>

 			</div>
 			<div class="col-md-4">
 				<div class="content__box content__box_fill">
-					<p><i> 如果一些容器强耦合并且需要共享资源(例如 磁盘)，那么这些容器应该放到单个 Pod 中一起调度。 </i></p>
+					<p><i> 如果一些容器属于强耦合并且需要共享资源(例如 磁盘)，那么这些容器应该放到单个 Pod 中一起调度。 </i></p>
 				</div>
 			</div>
 		</div>
@@ -93,7 +93,7 @@ title: 查看 Pods 和 Nodes

 		<div class="row">
 			<div class="col-md-8">
-				<h2 style="color: #3771e3;">Node 概述</h2>
+				<h2 style="color: #3771e3;">节点概述</h2>
 			</div>
 		</div>

@@ -107,7 +107,7 @@ title: 查看 Pods 和 Nodes
 		<div class="row">
 			<div class="col-md-8">
 				<h2>使用 kubectl 进行故障排除</h2>
-				<p>在模块 <a href="/docs/tutorials/kubernetes-basics/deploy-intro/">2</a>中，您使用了 Kubectl 命令行接口。您将在模块 3 中继续使用它来获取有关已部署应用程序及其环境信息。最常见的操作可以通过以下 kubectl 命令完成:</p>
+				<p>在模块 <a href="/docs/tutorials/kubernetes-basics/deploy-intro/">2</a>中，您使用了 Kubectl 命令行接口。您将在模块 3 中继续使用它来获取有关已部署应用程序及其环境的信息。最常见的操作可以通过以下 kubectl 命令完成:</p>
 				<ul>
 					<li><b>kubectl get</b> - 列出可用资源</li>
 					<li><b>kubectl describe</b> - 显示有关资源的详细信息</li>
@@ -122,7 +122,7 @@ title: 查看 Pods 和 Nodes
 			</div>
 			<div class="col-md-4">
 				<div class="content__box content__box_fill">
-					<p><i> Node 是 Kubernetes 中的工作机器，可能是物理机或虚拟机，具体取决于集群的安装配置。多个 Pod 可以在一个 Node 上运行。 </i></p>
+					<p><i> 节点是 Kubernetes 中的工作机器，可能是物理机或虚拟机，具体取决于集群的安装配置。多个 Pod 可以在一个节点上运行。 </i></p>
 				</div>
 			</div>
 		</div>
@@ -130,7 +130,7 @@ title: 查看 Pods 和 Nodes

 		<div class="row">
 			<div class="col-md-12">
-				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/explore-interactive/" role="button">启动交互式教程<span class="btn__next">›</span></a>
+				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/explore-interactive/" role="button">启动互动教程<span class="btn__next">›</span></a>
 			</div>
 		</div>

@@ -1,5 +1,5 @@
 ---
-title: 交互性教程 - 应用外部可见
+title: 互动教程 - 应用外部可见
 ---

 <!DOCTYPE html>
@@ -1,5 +1,5 @@
 ---
-title: 使用服务让您的应用程序外部可见
+title: 使用服务发布您的应用程序
 ---

 <!DOCTYPE html>
@@ -15,40 +15,41 @@ title: 使用服务让您的应用程序外部可见
 	<main class="content">

 		<div class="row">
-
-     <div class="col-md-8">
-      	<h3>目标</h3>
+			<div class="col-md-8">
+    		<h3>目标</h3>
 				<ul>
-					<li>了解 Kubernetes 服务</li>
-					<li>了解 Kubernetes 标签</li>
-					<li>应用程序在 Kubernetes 外部可见</li>
+					<li>了解 Kubernetes 中的服务</li>
+					<li>了解标签和标签选择器对象如何与服务相关联</li>
+					<li>通过 Service 在 Kubernetes 集群外发布应用程序</li>
 				</ul>
 			</div>

 			<div class="col-md-8">
-			<h3>Kubernetes Services</h3>
+			<h3>Kubernetes 服务概述</h3>

-			<p>虽然每个 Pod 在所在的集群中拥有自己独立的 IP 地址，但这些 IP 地址不会暴露在 Kubernetes 集群外部。考虑到 Pod 可能随时会被终止、删除或被其他 Pod 替换，我们需要一种方法让其他 Pod 和应用程序自动发现彼此。Kubernetes 通过 Service 对 Pods 进行分组来解决此问题。一个 Kubernetes <b>Service</b> 是一个抽象层，它定义了一组逻辑的 Pods，并让这些 Pods 对外部流量可见，可以被负载均衡和服务发现。 </p>
+			<p>Kubernetes <a href="/docs/concepts/workloads/pods/pod-overview/">Pods</a> 终有一死. Pods 实际上有一个 <a href="/docs/concepts/workloads/pods/pod-lifecycle/">生命周期</a>. 当工作节点死机时, 节点上运行的Pod也将丢失。 一个 <a href="/docs/user-guide/replication-controller/#what-is-a-replicationcontroller">ReplicationController</a> 可能会通过创建新的Pod以动态地将集群恢复到所需的状态，以保持您的应用程序运行。还有一种方法就是：决定是否使用具有3个副本的图像处理后端。这些副本是可替代的前端系统不应关心后端副本，即使Pod丢失并重建也不会更改。 也就是说，Kubernetes 集群中的每个 Pod 都有一个唯一的IP地址，即使在同一个节点上的 Pods 也是如此，所以此时就需要一种自动调整更改 Pod 的方法, 以便您的应用程序继续运行。输入 <i>服务</i>. Kubernetes 中的服务是一个抽象对象，它定义了一组逻辑的 Pods 和一个访问它们的策略。 服务让互相依赖的 Pod 之间的耦合松动。 服务由 YAML <a href="/docs/concepts/configuration/overview/#general-config-tips">(首选)</a> 或 JSON 定义。像所有 Kubernetes 对象一样。 针对服务的一组 Pod 通常由<i>Label选择器</i>确定（参见下文，为什么您可能希望不将 <code>选择器</code> 包含在规范中。</p>

-			<p>此抽象允许我们将 Pods 暴露给集群外部的流量访问。Services 具有自己的唯一集群专用 IP 地址，并显示一个端口以接收流量。如果选择在集群外公开 Service，则有如下选项:</p>
+			<p>虽然每个 Pod 都有一个唯一的 IP 地址，但是这些 IP 不会在没有服务的情况下公开在群集之外。服务允许您的应用程序接收流量。 可以通过在 ServiceSpec 中指定<code>类型</code> 以不同方式显示服务：</p>
 			<ul>
-				<li>LoadBalancer - 提供公有 IP 地址 (在 GCP 或 AWS 上运行 Kubernetes 通常使用此方式)</li>
-				<li>NodePort - 使用 NAT 在集群的每个 Node 节点的同一端口让服务可见。(所有 Kubernetes 集群和 Minikube 中都可用此方式)</li>
+				<li><i>ClusterIP</i>(默认) - 在集群中的内部IP上公开服务。此类型使服务只能从集群中访问。</li>
+				<li><i>NodePort</i> —— 使用NAT在群集中每个选定的节点的同一端口上显示该服务。使用 <code><NodeIP>:<NodePort></code>可以从群集外部访问服务。建立 ClusterIP 的超集.</li>
+				<li><i>LoadBalancer</i> —— 在当前云中创建外部负载平衡器(如果支持)，并为服务分配固定的外部IP。建立 NodePort 的超集。</li>
+				<li><i>ExternalName</i> —— 使用任意名称显示该服务(由规范中的<code>externalName</code> 指定)，本过程通过使用该名称返回 CNAME 记录达成。无须使用代理。这种类型需要 v1.7 或更高版本的 <code>kube-dns</code>.</li>
 			</ul>
+			<p>有关不同类型服务的详细信息，请参见 <a href="/docs/tutorials/services/source-ip/">使用源IP</a> 教程。另请参阅 <a href="/docs/concepts/services-networking/connect-applications-service">使用服务连接应用程序</a>.</p>
+			<p>另外，请注意，服务中有一些使用案例涉及在规范中不定义<code>选择器</code> 。不使用 <code>选择器</code> 创建的服务也不会创建相应的端点对象。 这允许用户手动将服务映射到特定端点。没有选择器还有可能是因为您严格地使用了 <code>type: ExternalName</code>.</p>
 			</div>
 			<div class="col-md-4">
 				<div class="content__box content__box_lined">
-					<h3>摘要:</h3>
+					<h3>摘要</h3>
 					<ul>
-						<li>Pod 流量外部可见</li>
-						<li>Pods 流量负载均衡</li>
+						<li>对外部流量曝光 Pod </li>
+						<li>跨多个 Pods 进行流量负载均衡</li>
 						<li>使用标签</li>
 					</ul>
 				</div>
 				<div class="content__box content__box_fill">
-						<p><i>
-							Kubernetes Service 是一个抽象层，它定义了一组逻辑的 Pods，并为这些 Pods 启用了外部流量访问、负载均衡和服务发现。
-						</i></p>
+						<p><i>Kubernetes 服务是一个抽象层，它定义了一组逻辑的Pods，并为这些Pods启用了外部流量曝光、负载平衡和服务发现。</i></p>
 				</div>
 			</div>
 		</div>
@@ -56,57 +57,35 @@ title: 使用服务让您的应用程序外部可见

 		<div class="row">
 			<div class="col-md-8">
-				<h2 style="color: #3771e3;">Services 概述</h2>
+				<h3>服务和标签</h3>
 			</div>
 		</div>

 		<div class="row">
 			<div class="col-md-8">
-				<p><img src="/docs/tutorials/kubernetes-basics/public/images/module_04_services.svg"></p>
-			</div>
-		</div>
-		<br>
-
-		<div class="row">
-			<div class="col-md-8">
-
-				<p>一个 Service 提供了一组 Pods 的流量负载均衡。通过创建服务以对来自特定部署的所有 Pods 进行分组时，这是有用的(当我们有多个实例运行时，我们的应用程序将在下一个模块中使用这一点)。</p>
-
-				<p>Services 还负责集群内部的服务发现 (包含在 <a href="/docs/user-guide/connecting-applications/#accessing-the-service">访问服务</a>中)。 例如，这将允许前端服务 (如 web 服务器) 从后端服务 (如 数据库) 接收流量，而不必考虑 Pod。 </p>
-
-				<p>Services 使用标签选择器匹配一组 Pods，标签选择器支持在标签上进行原始逻辑分组的能力。</p>
-
-			</div>
-			<div class="col-md-4">
-				<div class="content__box content__box_fill">
-					<p><i> 您可以通过添加 --expose 作为 kubectl 运行命令的参数，在创建 Deployment 的同时创建 Service。 </i></p>
-				</div>
+				<p><img src="/docs/tutorials/kubernetes-basics/public/images/module_04_services.svg" width="150%" height="150%"></p>
 			</div>
 		</div>

-		<br>
-
 		<div class="row">
 			<div class="col-md-8">
-				<p><b>Labels</b> 是附加到对象的 键/值对，例如 Pods，您可以将它们视为社交媒体的标签符号。它们用于以对用户有意义的方式组织相关对象，如:</p>
+				<p> A服务可以跨一组 Pod 路由流量。服务是允许 Pod 在 Kubernetes 中死亡和复制而不影响应用程序的抽象层。相关 Pod 之间的发现和路由(如应用程序中的前端和后端组件)是由 Kubernetes Services 处理的。</p>
+				<p> 服务使用 <a href="/docs/concepts/overview/working-with-objects/labels">标签和选择器</a>, 匹配一组 Pod，成为分组原语，此原语允许在 Kubernetes 中的对象进行逻辑运算。标签是一对附加到对象的关键/重要组，可以以多种方式使用，方式如下: </p>
 				<ul>
-					<li>生产环境 (生产、测试、开发)</li>
-					<li>应用程序版本 (beta、v1.3)</li>
-					<li>服务类型 (前端、后端、数据库)</li>
+					<li>指定用于开发、测试和生产的对象</li>
+					<li>嵌入版本标签</li>
+					<li>使用标签分类对象</li>
 				</ul>
+
 			</div>
 			<div class="col-md-4">
 				<div class="content__box content__box_fill">
-					<p><i> Labels 是附加到对象的键/值对。</i></p>
+					<p><i>您可以在使用<br><code>--expose</code> 在 kubectl 中创建部署的同时创建服务.</i></p>
 				</div>
 			</div>
 		</div>
+
 		<br>
-		<div class="row">
-			<div class="col-md-8">
-				<h2 style="color: #3771e3;">Labels</h2>
-			</div>
-		</div>

 		<div class="row">
 			<div class="col-md-8">
@@ -116,22 +95,16 @@ title: 使用服务让您的应用程序外部可见
 		<br>
 		<div class="row">
 			<div class="col-md-8">
-
-				<p>Labels 可以在创建时或以后附加到对象，并可以随时修改。
-				在使用 kubectl run 命令新建 Pods/Deployment 时，会设置一些默认的 Labels/Label。标签和标签选择器之间的链接定义了 Deployment 及其创建 Pod 之间的关系。</p>
-
-				<p>现在，让我们在 Service 的帮助下公开我们的应用程序，并应用一些新的标签。</p>
+				<p>标签可以在创建时或之后附加到对象后，并支持随时修改。让我们现在开始使用服务公开我们的应用程序并应用一些标签吧。</p>
 			</div>
 		</div>
 		<br>
 		<div class="row">
 			<div class="col-md-12">
-				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/expose-interactive/" role="button">启动交互式教程<span class="btn__next">›</span></a>
+				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/expose-interactive/" role="button">启动互动教程<span class="btn__next">›</span></a>
 			</div>
 		</div>
-
 	</main>
-
 </div>

 </body>
@@ -17,15 +17,15 @@ title: 概述
    <div class="row">
      <div class="col-md-9">
        <h2>Kubernetes 基础</h2>
-        <p>本教程介绍了 Kubernetes 集群编排系统的基础知识。每个模块包含关于 Kubernetes 主要特性和概念的一些背景信息，并包括一个交互式在线教程。这些交互式教程让您可以自己管理一个简单的集群及其容器化应用程序。</p>
-        <p>使用交互式教程，您可以学习:</p>
+        <p>本教程介绍了 Kubernetes 集群编排系统的基础知识。每个模块包含关于 Kubernetes 主要特性和概念的一些背景信息，并包括一个在线互动教程。这些互动教程让您可以自己管理一个简单的集群及其容器化应用程序。</p>
+        <p>使用互动教程，您可以学习:</p>
        <ul>
        <li>在集群上部署容器化应用程序</li>
        <li>弹性部署</li>
        <li>使用新的软件版本，更新容器化应用程序</li>
        <li>调试容器化应用程序</li>
        </ul>
-        <p>教程 Katacoda 在您的浏览器中运行一个虚拟终端，在浏览器中运行 Minikube，这是一个可在任何地方小规模本地部署的 Kubernetes 集群。没有安装任何软件或进行任何配置; 每个交互性教程都直接从您的网页浏览器上运行。</p>
+        <p>教程 Katacoda 在您的浏览器中运行一个虚拟终端，在浏览器中运行 Minikube，这是一个可在任何地方小规模本地部署的 Kubernetes 集群。不需要安装任何软件或进行任何配置; 每个交互性教程都直接从您的网页浏览器上运行。</p>
      </div>
    </div>

@@ -34,7 +34,7 @@ title: 概述
    <div class="row">
      <div class="col-md-9">
        <h2>Kubernetes 可以为您做些什么?</h2>
-        <p>现代的 Web 服务，用户希望应用程序能够 24/7 全天候使用，开发人员希望每天可以多次发布部署新版本的应用程序。 容器化可以帮助软件包服务于这些目标，使应用程序能够以简单快速的方式发布和更新，而无需停机。Kubernetes 帮助您确保这些容器化的应用程序在您想要的地方和时间运行，并帮助应用程序找到它们需要的资源的工具。 <a href="http://kubernetes.io/docs/whatisk8s/">Kubernetes</a>  是一个生产可用的开源平台，具有 Google 容器集群方面的设计与经验积累，拥有来自社区的最佳实践。</p>
+        <p>通过现代的 Web 服务，用户希望应用程序能够 24/7 全天候使用，开发人员希望每天可以多次发布部署新版本的应用程序。 容器化可以帮助软件包达成这些目标，使应用程序能够以简单快速的方式发布和更新，而无需停机。Kubernetes 帮助您确保这些容器化的应用程序在您想要的时间和地点运行，并帮助应用程序找到它们需要的资源和工具。 <a href="http://kubernetes.io/docs/whatisk8s/">Kubernetes</a>  是一个可用于生产的开源平台，根据 Google 容器集群方面积累的经验，以及来自社区的最佳实践而设计。</p>
      </div>
    </div>

@@ -77,7 +77,7 @@ title: 概述
          <div class="thumbnail">
            <a href="/docs/tutorials/kubernetes-basics/scale-intro/"><img src="./public/images/module_05.svg?v=1469803628347" alt=""></a>
            <div class="caption">
-              <a href="scale-intro/"><h5>5. 应用可伸缩</h5></a>
+              <a href="scale-intro/"><h5>5. 应用可扩展</h5></a>
            </div>
          </div>
        </div>
@@ -1,5 +1,5 @@
 ---
-title: 交互式教程 - 扩展您的应用程序
+title: 互动教程 - 扩展您的应用程序
 ---

 <!DOCTYPE html>
@@ -19,14 +19,15 @@ title: 运行应用程序的多个实例
     <div class="col-md-8">
      	<h3>目标</h3>
 				<ul>
-					<li>使用 kubectl 缩放应用程序</li>
+					<li>使用 kubectl 伸缩应用程序</li>
 				</ul>
 			</div>

 			<div class="col-md-8">
-       <h3>缩放应用程序</h3>
+       <h3>应用程序伸缩</h3>

-			<p>在之前的模块中，我们创建了一个 <a href="http://kubernetes.io/docs/user-guide/deployments/"> Deployment</a>，然后通过 <a href="http://kubernetes.io/docs/user-guide/services/">Service</a>让应用程序外部可见。Deployment 仅为我们的应用程序创建了一个 Pod。 当流量增加时，我们将需要扩展应用程序以跟上用户需求。</p>
+			<p>在之前的模块中，我们创建了一个 <a href="http://kubernetes.io/docs/user-guide/deployments/"> Deployment</a>，然后通过 <a href="http://kubernetes.io/docs/user-guide/services/">Service</a>让应用程序外部可见。Deployment 仅为我们的应用程序创建了一个 Pod。 当流量增加时，我们将需要
+				应用程序以跟上用户需求。</p>

 			<p><b>Scaling</b> 是通过更改 Deployment 中的副本数量实现的。</p>

@@ -35,7 +36,7 @@ title: 运行应用程序的多个实例
 				<div class="content__box content__box_lined">
 					<h3>摘要:</h3>
 					<ul>
-						<li>Deployment 的缩放</li>
+						<li>Deployment 的伸缩</li>
 					</ul>
 				</div>
 				<div class="content__box content__box_fill">
@@ -101,14 +102,14 @@ title: 运行应用程序的多个实例

 		<div class="row">
 			<div class="col-md-8">
-				<p> 一旦您有应用程序的多个实例，您将能够滚动更新而不会停止服务。我们将在下一个模块中介绍。现在，我们去在线终端扩展我们的应用程序。</p>
+				<p> 一旦您有应用程序的多个实例，您将能够滚动更新，而不会停止服务————我们将在下一个模块中介绍这些。现在，我们去在线终端对我们的应用程序进行伸缩。</p>
 			</div>
 		</div>
 		<br>

 		<div class="row">
 			<div class="col-md-12">
-				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/scale-interactive/" role="button">启动交互式教程 <span class="btn__next">›</span></a>
+				<a class="btn btn-lg btn-success" href="/docs/tutorials/kubernetes-basics/scale-interactive/" role="button">启动互动教程 <span class="btn__next">›</span></a>
 			</div>
 		</div>

@@ -1,5 +1,5 @@
 ---
-title: 交互式教程 - 更新您的应用程序
+title: 互动教程 - 更新您的应用程序
 ---

 <!DOCTYPE html>
@@ -26,9 +26,9 @@ title: 执行滚动更新
 			<div class="col-md-8">
 			<h3>更新应用程序</h3>

-			<p>用户期望应用程序始终可用，并且开发人员有望每天部署新版本。这就是 Kubernetes 的滚动更新。 <b>Rolling updates</b> 允许通过使用新的 Pods 实例逐个更新来实现零停机的更新部署。新的 Pods 会被调度到可用资源的 Node 节点上。</p>
+			<p>用户期望应用程序始终可用，并且希望开发人员每天部署新版本。在 Kubernetes 上这通过滚动更新(Rolling updates)达成。 <b>Rolling updates</b> 允许通过使用新的 Pods 实例逐个更新来实现零停机的部署更新。新的 Pods 会被调度到可用资源的 Node 节点上。</p>

-			<p>在上一个模块中，我们将应用程序扩展为运行多个实例。这是执行更新但不影响应用可用性的要求。默认情况下，更新期间最大数量的 Pods 可能不可用，此时创建和更新 Pod 的最大数量是一。 这两个选项可以配置为数字或百分比(Pods)。
+			<p>在上一个模块中，我们将应用程序扩展为运行多个实例。这也是执行更新但不影响应用可用性所需的条件。默认情况下，更新期间最大数量的不可用 Pod 以及最大数量的新 Pod 是一。 这两个选项可以配置为数字或百分比(Pods)。
 			在 Kubernetes 中，更新已版本化，任何部署更新都可以恢复到以前的 (稳定) 版本。</p>

 			</div>
@@ -94,13 +94,13 @@ title: 执行滚动更新
 		<div class="row">
 			<div class="col-md-8">

-				<p>与应用程序缩放类似，如果 Deployment 外部可见，则 Service 将在更新期间将流量负载均衡到可用的 Pod。可用的 Pod 指的是应用程序用户可用的实例。</p>
+				<p>与应用程序伸缩类似，如果 Deployment 外部可见，则服务将在更新期间将流量负载均衡到可用的 Pod。可用的 Pod 指的是应用程序用户可用的实例。</p>

 				<p>滚动更新允许以下操作:</p>
 				<ul>
 					<li>将应用程序从一个环境升级到另一个环境 (通过容器镜像更新)</li>
 					<li>回滚到以前的版本</li>
-					<li>持续集成和持续交付，实现应用程序零故障</li>
+					<li>持续集成和持续交付，实现应用程序零停机</li>

 				</ul>

@@ -116,7 +116,7 @@ title: 执行滚动更新

 		<div class="row">
 			<div class="col-md-8">
-				<p> 在下面的交互式教程中，我们将把应用程序更新到一个新版本，并执行回滚。</p>
+				<p> 在下面的互动教程中，我们将把应用程序更新到一个新版本，并执行回滚。</p>
 			</div>
 		</div>
 		<br>
@@ -0,0 +1,145 @@
+---
+title: 使用命令式的方式管理 Kubernetes 对象
+redirect_from:
+- "/docs/concepts/tools/kubectl/object-management-using-imperative-commands/"
+- "/docs/concepts/tools/kubectl/object-management-using-imperative-commands.html"
+---
+
+{% capture overview %}
+直接使用内置的 `kubectl` 命令行工具，以命令式方式可以快速创建，更新和删除 Kubernetes 对象。本文档介绍了这些命令是如何组织的，以及如何使用它们来管理活动对象。
+{% endcapture %}
+
+{% capture body %}
+
+## 权衡
+
+`kubectl` 工具支持三种对象的管理:
+
+* 命令式的方式
+* 命令式的对象配置
+* 声明式的对象配置
+
+参见[Kubernetes对象管理](/docs/concepts/tools/kubectl/object-management-overview/)
+讨论各种对象管理的优缺点.
+
+## 如何创建对象
+
+`kubectl` 工具支持用于创建一些最常用的对象类型的动词驱动命令，这些命令被命名为对于不熟悉的用户也是一目了然。
+
+- `run`: 创建一个新的 Deployment 对象以在一个或多个 Pod 中运行 Containers。
+- `expose`: 创建一个新的 Service 对象用于负载均衡 Pods 上的的网络流量。
+- `autoscale`: 创建一个新的 Autoscaler 对象，即自动水平扩展控制器，提供 Deployment 自动水平伸缩支持。
+
+`kubectl` 工具也支持由对象类型驱动的创建命令。 这些命令支持更多的对象类型，并且对其意图更为明确，但要求用户知道他们打算创建的对象的类型。
+
+ - `create <objecttype> [<subtype>] <instancename>`
+
+某些对象类型具有您可以在“create"命令中指定的子类型.
+例如，Service对象有几种子类型，包括ClusterIP，
+LoadBalancer和NodePort. 以下是创建一个服务的示例
+子类型NodePort:
+
+一些对象类型允许你在 `create` 命令中指定子命令。例如，Service 对象拥有几个子命令，包括 ClusterIP、LoadBalancer 和 NodePort。以下是使用子命令 NodePort 创建服务的示例:
+
+
+```shell
+kubectl create service nodeport <myservicename>
+```
+
+在前面的例子中，调用 `create service nodeport`命令是 `create service`命令的子命令.
+
+您可以使用 `-h` 标志来查找子命令支持的参数和标志:
+
+```shell
+kubectl create service nodeport -h
+```
+
+## 如何更新对象
+
+`kubectl` 命令支持一些常见更新操作的动词驱动命令。这样命名可以让不熟悉 Kubernetes 对象的用户，在不知道必须设置的特定字段的情况下也可以执行更新操作:
+
+ - `scale`: 通过更新控制器的副本数量，水平扩展控制器以添加或删除 Pod。
+ - `annotate`: 从对象添加或删除注释。
+ - `label`: 为对象添加或删除标签。
+
+`kubectl`命令还支持由对象的一个切面驱动的更新命令.设置此切面可能会为不同的对象类型设置不同的字段:
+
+ - `set` <field>: 设置对象的一个切面.
+
+**注**: 在 Kubernetes 版本 1.5 中，并不是每个动词驱动的命令都有一个相关的切面驱动的命令.
+
+`kubectl` 工具支持直接更新活动对象的其他方法，然而，它们需要更好的了解 Kubernetes 对象模式。
+
+- `edit`: 通过在编辑器中打开其配置，直接编辑活动对象的原始配置。
+- `patch`: 通过使用补丁字符串直接修改活动对象的特定字段。
+
+有关补丁字符串的更多详细信息，请参阅补丁部分
+[API 公约](https://github.com/kubernetes/community/blob/master/contributors/devel/api-conventions.md#patch-operations).
+
+## 如何删除对象
+
+您可以使用 `delete` 命令从集群中删除一个对象:
+
+ - `delete <type>/<name>`
+
+ **注意**: 您可以对命令式命令和命令式对象配置都使用 `kubectl delete` 方法。两者的差异在于传递的命令参数不同。要将
+ `kubectl delete` 作为命令式命令使用，将要删除的对象作为参数传递。以下是传递名为 nginx 的 Deployment 对象的示例:
+
+```shell
+kubectl delete deployment/nginx
+```
+
+## 如何查看对象
+
+{% comment %}
+TODO(pwittrock): 实现时取消注释.
+
+您可以使用 `kubectl view` 打印指定对象的字段。
+
+- `view`: 打印对象的特定字段的值。
+
+{% endcomment %}
+
+
+
+有几个命令用于打印有关对象的信息:
+
+- `get`: 打印有关匹配对象的基本信息。使用 `get -h` 来查看选项列表。
+- `describe`: 打印有关匹配对象的聚合详细信息。
+- `logs`: 打印 Pod 运行容器的 stdout 和 stderr 信息。
+
+##  使用 `set` 命令在创建之前修改对象
+
+有一些对象字段没有可以使用的标志，在 `create` 命令中。在某些情况下，您可以使用组合 `set` 和 `create` 为对象之前的字段指定一个值创建。这是通过将 `create` 命令的输出管道连接到 `set` 命令，然后回到 `create` 命令。以下是一个例子:
+
+```sh
+kubectl create service clusterip <myservicename> -o yaml --dry-run | kubectl set selector --local -f - 'environment=qa' -o yaml | kubectl create -f -
+```
+
+1.  使用 `create service -o yaml --dry-run` 创建服务配置，并将其作为 YAML 打印到 stdout，而不是将其发送到 Kubernetes API 服务器。
+1.  使用 `set --local -f - -o yaml` 从 stdin 读取配置，并将更新后的配置作为 YAML 写入 stdout。
+1.  使用 `kubectl create -f -` 从 stdin 提供的配置创建对象。
+
+## 使用 `--edit` 在创建之前修改对象
+
+您可以使用 `kubectl create --edit` 命令在对象创建之前，对对象进行任意更改。以下是一个例子:
+
+```sh
+kubectl create service clusterip my-svc -o yaml --dry-run > /tmp/srv.yaml
+kubectl create --edit -f /tmp/srv.yaml
+```
+
+1. 使用`create service` 创建服务的配置并将其保存到 `/tmp/srv.yaml`。
+1. 使用`create --edit` 在创建对象之前打开配置文件进行编辑。
+
+
+{% endcapture %}
+
+{% capture whatsnext %}
+ -  [使用对象配置管理 Kubernetes 对象(必要)](/docs/tutorials/object-management-kubectl/imperative-object-management-configuration/)
+ -  [使用对象配置(声明式)管理 Kubernetes 对象](/docs/tutorials/object-management-kubectl/declarative-object-management-configuration/)
+ -  [Kubectl 命令参考](/docs/user-guide/kubectl/v1.6/)
+ -  [Kubernetes 对象模式参考](/docs/resources-reference/v1.6/)
+ {% endcapture %}
+
+ {% include templates/concept.md %}
@@ -0,0 +1,157 @@
+---
+title: Kubernetes 对象管理
+redirect_from:
+- "/docs/concepts/tools/kubectl/object-management-overview/"
+- "/docs/concepts/tools/kubectl/object-management-overview.html"
+- "/docs/user-guide/working-with-resources/"
+- "/docs/user-guide/working-with-resources.html"
+---
+
+{% capture overview %}
+`kubectl` 命令行工具支持 Kubernetes 对象几种不同的创建和管理方法。本文档简要介绍了这些方法.
+{% endcapture %}
+
+{% capture body %}
+
+## 管理技巧
+
+**警告:** Kubernetes 对象应该只使用一种技术进行管理。混合使用不同的技术，会导致相同对象出现未定义的行为。
+
+| 管理技术             | 操作         |推荐环境 | 支持撰写  | 学习曲线 |
+|----------------------------------|----------------------|------------------------|--------------------|----------------|
+| 命令式的方式              | 活动对象         | 开发项目   | 1+                 | 最低         |
+| 命令式对象配置  | 单文件     | 生产项目    | 1                  | 中等       |
+| 声明式对象配置 | 文件目录 | 生产项目    | 1+                 | 最高        |
+
+## 命令式的方式
+
+当使用命令式的命令时，用户直接对集群中的活动对象进行操作。用户提供 `kubectl` 命令的参数或标记进行操作。
+
+这是在集群中启动或运行一次性任务的最简单的方法。因为这种技术直接在活动对象上运行，所以它没有提供以前配置的历史记录。
+
+### 例子
+
+通过创建 Deployment 对象来运行 nginx 容器的实例:
+
+```sh
+kubectl run nginx --image nginx
+```
+
+使用不同的语法做同样的事情:
+
+```sh
+kubectl create deployment nginx --image nginx
+```
+
+### 权衡
+
+与对象配置相比的优点:
+
+ - 命令简单易学，易于记忆。
+ - 命令只需要一个步骤即可对群集进行更改。
+
+与对象配置相比的缺点:
+
+ - 命令不与变更审核流程整合。
+ - 命令不提供与更改相关联的审计跟踪。
+ - 除了活动对象之外，命令不提供记录来源。
+ - 命令不提供用于创建新对象的模板。
+
+## 命令式对象配置
+
+在命令式对象配置中，`kubectl` 命令指定操作(创建，替换等)，可选标志和至少一个文件名称。指定的文件必须包含对象的完整定义以 YAML 或 JSON 格式。
+
+请参阅[参考资源](https://kubernetes.io/docs/resources-reference/v1.6/)
+查看有关对象定义的更多细节。
+
+**警告:** 命令式 `replace` 命令用新提供的命令替换现有资源规格，将对配置文件中缺少的对象的所有更改都丢弃。这种方法不应更新与配置文件无关的资源类型。例如，`LoadBalancer` 类型的服务使其 `externalIPs` 字段与集群的配置无关。
+
+### 例子
+
+创建对象定义配置文件:
+
+```sh
+kubectl create -f nginx.yaml
+```
+
+删除两个配置文件中定义的对象:
+
+```sh
+kubectl delete -f nginx.yaml -f redis.yaml
+```
+
+通过覆写实时配置更新配置文件中定义的对象:
+
+```sh
+kubectl replace -f nginx.yaml
+```
+
+### 权衡
+
+与命令式的命令相比的优点:
+
+ - 对象配置可以存储在源码控制系统中，如Git。
+ - 对象配置可以与进程集成，例如在推送和审计跟踪之前查看更改。
+ - 对象配置提供了一个用于创建新对象的模板。
+
+与命令式的命令相比的缺点:
+
+ - 对象配置需要对对象模式有基本的了解。
+ - 对象配置需要编写 YAML 文件的附加步骤。
+
+与声明式对象配置相比的优势:
+
+ - 命令对象配置行为更简单易懂。
+ - 至于 Kubernetes 1.5 版本，命令式对象配置更为成熟。
+
+与声明式对象配置相比的缺点:
+
+ - 命令对象配置最适合于文件，而不是目录。
+ - 活动对象的更新必须反映在配置文件中，否则在下次更替时将丢失。
+
+## 声明式对象配置
+
+当使用声明式对象配置时，用户对本地存储的对象配置文件进行操作，但是用户没有定义要对文件执行的操作。通过 `kubectl` 自动检测每个对象进行创建、更新和删除操作。这样可以在目录层级上工作，因为不同的对象可能需要不同的操作。
+
+**注意:** 声明式对象配置保留由其他对象进行的更改，即使更改未合并到对象配置文件中。这可以通过使用 `patch` API 操作来写入观察到的差异，而不是使用`replace` API 操作来替换整个对象的配置。
+
+### 例子
+
+处理`configs` 目录中的所有对象配置文件，创建或修补(patch)活动对象:
+
+```sh
+kubectl apply -f configs/
+```
+
+递归处理目录:
+
+```sh
+kubectl apply -R -f configs/
+```
+
+### 权衡
+
+与命令式对象配置相比的优点:
+
+ - 直接对活动对象进行的更改将被保留，即使它们未被并入到配置文件中。
+ - 声明式对象配置更好地支持目录操作，并自动检测每个对象的操作类型 (创建、修补，删除)。
+
+与命令式对象配置相比的缺点:
+
+- 声明式对象配置在意外情况下难以调试和了解结果。
+- 使用差异的部分更新会创建复杂的合并和补丁操作。
+
+ {% endcapture %}
+
+ {% capture whatsnext %}
+ -  [使用命令式的命令管理 Kubernetes 对象](/docs/tutorials/object-management-kubectl/imperative-object-management-command/)
+ -  [使用对象配置管理 Kubernetes 对象(必要)](/docs/tutorials/object-management-kubectl/imperative-object-management-configuration/)
+ -  [使用对象配置(声明式)管理 Kubernetes 对象](/docs/tutorials/object-management-kubectl/declarative-object-management-configuration/)
+ -  [Kubectl 命令参考](/docs/user-guide/kubectl/v1.6/)
+ -  [Kubernetes 对象模式参考](/docs/resources-reference/v1.6/)
+
+ {% comment %}
+ {% endcomment %}
+ {% endcapture %}
+
+ {% include templates/concept.md %}
@@ -1,6 +1,7 @@
 ---
 assignees:
 - k8s-merge-robot
+
 title: 认识 Kubernetes?
 ---

@@ -0,0 +1,453 @@
+#caseStudyTitle {
+    margin-top: 1em !important;
+    font-family:"Roboto", sans-serif;
+}
+
+body {
+
+  background-color:#ffffff;
+}
+
+p {
+  font-family:"Roboto", sans-serif;
+  padding:5%;
+}
+
+a {
+  text-decoration:none;
+  color:#3366ff;
+}
+
+body {
+  margin:0;
+
+}
+
+h1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:bold;
+  letter-spacing:0.025em;
+  font-size:42px;
+  padding-bottom:0px;
+}
+
+.subhead {
+  font-size:26px;
+  font-weight:100;
+  line-height:40px;
+  padding-bottom:1%;
+
+}
+
+.banner1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:12%;
+  padding-bottom:0.5%;
+  padding-left:9.9%;
+  font-size:32px;
+  background: url('/images/CaseStudy_box_banner1.jpg');
+  background-size:100% auto;
+  background-repeat:no-repeat;
+
+}
+
+.banner2 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:3%;
+  padding-bottom:3%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background-size:100% auto;
+  background-color:#666666;
+  background-repeat:no-repeat;
+
+}
+
+.banner3 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background: url('/images/CaseStudy_box_banner3.jpg');
+  background-size:100% auto;
+}
+
+.banner4 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background: url('/images/CaseStudy_box_banner4.jpg');
+  background-size:100% auto;
+}
+
+.banner5 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:3%;
+  padding-bottom:3%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background-size:100% auto;
+  background-color:#666666;
+  background-repeat:no-repeat;
+}
+
+.banner2text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:60%;
+  padding-left:19%;
+  float:left;
+  text-align:center;
+}
+
+.banner3text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:55%;
+  padding-left:21%;
+  text-align:center;
+}
+
+.banner4text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:55%;
+  padding-left:21%;
+  text-align:center;
+}
+
+.banner5text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:60%;
+  padding-left:19%;
+  float:left;
+  text-align:center;
+}
+
+
+h2 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:24px;
+  line-height:34px;
+  color:#3366ff;
+}
+
+.quote {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:22px;
+  line-height:32px;
+  color:#3366ff;
+}
+
+.details {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:18px;
+  color:#3366ff;
+  letter-spacing:0.03em;
+  padding-bottom:1.5%;
+  padding-top:2%;
+  padding-left:10%;
+}
+
+
+
+hr {
+  border-bottom:0px solid;
+  width:100%;
+  opacity:0.5;
+  color:#aaaaaa;
+  height:1px;
+}
+
+.col1 {
+
+width: 38%;
+padding-left:5%;
+padding-right:8%;
+float:left;
+font-family:"Roboto", sans-serif;
+font-weight:100;
+color:#606060;
+line-height:20px;
+  letter-spacing:0.03em;
+font-size:14px;
+
+}
+
+.col2 {
+
+width: 44%;
+font-family:"Roboto", sans-serif;
+font-weight:300;
+float:left;
+line-height:20px;
+color:#606060;
+  letter-spacing:0.03em;
+font-size:14px;
+
+}
+
+
+
+.fullcol {
+  width:77%;
+  margin-left:11%;
+  margin-right:10%;
+  margin-top:4%;
+  margin-bottom:6%;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  float:left;
+  line-height:22px;
+  color:#606060;
+  letter-spacing:0.03em;
+  font-size:14px;
+}
+
+.cols {
+  width:77%;
+  margin-left:6%;
+  margin-top:1%;
+  margin-bottom:4%;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  float:left;
+
+}
+
+h4 {
+  font-family:"Roboto", sans-serif;
+  font-weight:400;
+  letter-spacing:0.9;
+  font-size:20px;
+  padding-bottom:0px;
+}
+
+
+@media screen and (max-width: 910px){
+
+h1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:bold;
+  line-height:36px;
+  letter-spacing:0.03em;
+  font-size:30px !important;
+  padding-bottom:0px;
+  width:80%;
+}
+
+.subhead {
+  font-size:18px;
+  font-weight:100;
+  line-height:27px;
+}
+
+.details {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:16px;
+  color:#3366ff;
+  letter-spacing:0.03em;
+  padding-bottom:2%;
+  line-height:28px;
+  padding-top:4%;
+  padding-left:10%;
+}
+
+.logo {
+    width:8%;
+}
+
+.col1 {
+  width: 100%;
+  padding-left:5%;
+  padding-right:8%;
+  float:left;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#606060;
+  line-height:20px;
+  letter-spacing:0.03em;
+  font-size:14px;
+}
+
+.col2 {
+  width: 100%;
+  padding-left:5%;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  float:left;
+  line-height:20px;
+  color:#606060;
+  letter-spacing:0.03em;
+  font-size:14px;
+}
+
+.banner1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:15%;
+  padding-bottom:2%;
+  padding-left:10%;
+  font-size:18px;
+  background: url('/images/CaseStudy_box_banner1.jpg');
+  background-size:100% auto;
+}
+
+.banner2 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:4%;
+  padding-bottom:4%;
+  padding-left:0%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background:none;
+  background-color:#666666;
+}
+
+.banner3 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background: url('/images/CaseStudy_box_banner3.jpg');
+}
+
+.banner4 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background: url('/images/CaseStudy_box_banner4.jpg');
+}
+
+.banner5 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:4%;
+  padding-bottom:4%;
+  padding-left:0%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background:none;
+  background-color:#666666;
+}
+
+.banner2text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  float:left;
+  text-align:center;
+  color:#ffffff;
+}
+
+.banner4text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  text-align:center;
+}
+
+.banner3text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  text-align:center;
+}
+
+.banner5text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  float:left;
+  text-align:center;
+  color:#ffffff;
+}
+
+.fullcol {
+  margin-top:6%;
+}
+
+h2 {
+  line-height:26px;
+  font-size:18px;
+}
+
+.quote {
+  font-size:18px;
+  line-height:24px;
+}
+
+.logo {
+  width:15%;
+}
+
+@media screen and (max-width: 480px){
+
+  .logo {
+    width:22%;
+    padding-bottom:2%;
+  }
+}
@@ -0,0 +1,454 @@
+#caseStudyTitle {
+    margin-top: 1em !important;
+    font-family:"Roboto", sans-serif;
+}
+
+p {
+  font-family:"Roboto", sans-serif;
+  padding:5%;
+}
+
+a {
+  text-decoration:none;
+  color:#3366ff;
+}
+
+body {
+  margin:0;
+
+}
+
+h1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:bold;
+  letter-spacing:0.025em;
+  font-size:42px;
+  padding-bottom:0px;
+}
+
+.subhead {
+  font-size:26px;
+  font-weight:100;
+  line-height:40px;
+  padding-bottom:1%;
+
+}
+
+.banner1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:12%;
+  padding-bottom:0.5%;
+  padding-left:9.9%;
+  font-size:32px;
+  background: url('/images/CaseStudy_golfnow_banner1.jpg');
+  background-size:100% auto;
+  background-repeat:no-repeat;
+}
+
+.banner2 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:3%;
+  padding-bottom:3%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background-size:100% auto;
+  background-color:#666666;
+  background-repeat:no-repeat;
+
+}
+
+.banner3 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-left:5%;
+  padding-right:5%;
+  padding-top:6%;
+  padding-bottom:6%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background: url('/images/CaseStudy_golfnow_banner3.jpg');
+  background-size:100% auto;
+}
+
+.banner4 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background: url('/images/CaseStudy_golfnow_banner4.jpg');
+  background-size:100% auto;
+}
+
+.banner5 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:3%;
+  padding-bottom:3%;
+  font-size:21px;
+  letter-spacing:0.03em;
+  line-height:32px;
+  float:left;
+  background-size:100% auto;
+  background-color:#666666;
+  background-repeat:no-repeat;
+}
+
+.banner2text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:60%;
+  padding-left:19%;
+  float:left;
+  text-align:center;
+}
+
+.banner3text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:70%;
+  padding-left:15%;
+  text-align:center;
+}
+
+.banner4text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:55%;
+  padding-left:21%;
+  text-align:center;
+}
+
+.banner5text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:60%;
+  padding-left:19%;
+  float:left;
+  text-align:center;
+}
+
+
+h2 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:24px;
+  line-height:34px;
+  color:#3366ff;
+}
+
+.quote {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:22px;
+  line-height:32px;
+  color:#3366ff;
+}
+
+.details {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:18px;
+  color:#3366ff;
+  letter-spacing:0.03em;
+  padding-bottom:1.5%;
+  padding-top:2%;
+  padding-left:10%;
+}
+
+
+
+hr {
+  border-bottom:0px solid;
+  width:100%;
+  opacity:0.5;
+  color:#aaaaaa;
+  height:1px;
+}
+
+.col1 {
+
+width: 38%;
+padding-left:5%;
+padding-right:8%;
+float:left;
+font-family:"Roboto", sans-serif;
+font-weight:100;
+color:#606060;
+line-height:20px;
+  letter-spacing:0.03em;
+font-size:14px;
+
+}
+
+.col2 {
+
+width: 44%;
+font-family:"Roboto", sans-serif;
+font-weight:300;
+float:left;
+line-height:20px;
+color:#606060;
+  letter-spacing:0.03em;
+font-size:14px;
+
+}
+
+
+
+.fullcol {
+  width:77%;
+  margin-left:11%;
+  margin-right:10%;
+  margin-top:4%;
+  margin-bottom:6%;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  float:left;
+  line-height:22px;
+  color:#606060;
+  letter-spacing:0.03em;
+  font-size:14px;
+}
+
+.cols {
+  width:77%;
+  margin-left:6%;
+  margin-top:1%;
+  margin-bottom:4%;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  float:left;
+
+}
+
+h4 {
+  font-family:"Roboto", sans-serif;
+  font-weight:400;
+  letter-spacing:0.9;
+  font-size:20px;
+  padding-bottom:0px;
+}
+
+
+@media screen and (max-width: 910px){
+
+h1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:bold;
+  line-height:36px;
+  letter-spacing:0.03em;
+  font-size:30px !important;
+  padding-bottom:0px;
+  width:80%;
+}
+
+.subhead {
+  font-size:18px;
+  font-weight:100;
+  line-height:27px;
+}
+
+.details {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  font-size:16px;
+  color:#3366ff;
+  letter-spacing:0.03em;
+  padding-bottom:2%;
+  line-height:28px;
+  padding-top:4%;
+  padding-left:10%;
+}
+
+.logo {
+    width:8%;
+}
+
+.col1 {
+  width: 100%;
+  padding-left:5%;
+  padding-right:8%;
+  float:left;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#606060;
+  line-height:20px;
+  letter-spacing:0.03em;
+  font-size:14px;
+}
+
+.col2 {
+  width: 100%;
+  padding-left:5%;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  float:left;
+  line-height:20px;
+  color:#606060;
+  letter-spacing:0.03em;
+  font-size:14px;
+}
+
+.banner1 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:15%;
+  padding-bottom:2%;
+  padding-left:10%;
+  font-size:18px;
+  background: url('/images/CaseStudy_golfnow_banner1.jpg');
+  background-size:100% auto;
+}
+
+.banner2 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:4%;
+  padding-bottom:4%;
+  padding-left:0%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background:none;
+  background-color:#666666;
+}
+
+.banner3 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:80%;
+  padding-left:15%;
+  padding-right:10%;
+  float:left;
+  background: url('/images/CaseStudy_golfnow_banner3.jpg');
+}
+
+.banner4 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:5%;
+  padding-bottom:5%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background: url('/images/CaseStudy_golfnow_banner4.jpg');
+}
+
+.banner5 {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  padding-top:4%;
+  padding-bottom:4%;
+  padding-left:0%;
+  font-size:18px;
+  letter-spacing:0.03em;
+  line-height:24px;
+  width:100%;
+  float:left;
+  background:none;
+  background-color:#666666;
+}
+
+.banner2text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  float:left;
+  text-align:center;
+  color:#ffffff;
+}
+
+.banner3text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:2%;
+  padding-right:10%;
+  padding-top:5%;
+  padding-bottom:5%;
+  text-align:center;
+}
+
+.banner4text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  text-align:center;
+}
+
+.banner5text {
+  font-family:"Roboto", sans-serif;
+  font-weight:300;
+  color:#ffffff;
+  width:80%;
+  padding-left:10%;
+  float:left;
+  text-align:center;
+  color:#ffffff;
+}
+
+.fullcol {
+  margin-top:6%;
+}
+
+h2 {
+  line-height:26px;
+  font-size:18px;
+}
+
+.quote {
+  font-size:18px;
+  line-height:24px;
+}
+
+.logo {
+  width:35%;
+}
+
+@media screen and (max-width: 480px){
+
+  .logo {
+    width:50%;
+    padding-bottom:5%;
+  }
+}
@@ -525,12 +525,65 @@ Here `v1.7.x` means the "latest patch release of the v1.7 branch".

 `${ARCH}` can be one of: `amd64`, `arm`, `arm64`, `ppc64le` or `s390x`.

+## Managing the kubeadm drop-in file for the kubelet
+
+The kubeadm deb package ships with configuration for how the kubelet should
+be run. Note that the `kubeadm` CLI command will never touch this drop-in file.
+This drop-in file belongs to the kubeadm deb/rpm package.
+
+This is what it looks like in v1.7:
+
+```
+[Service]
+Environment="KUBELET_KUBECONFIG_ARGS=--kubeconfig=/etc/kubernetes/kubelet.conf --require-kubeconfig=true"
+Environment="KUBELET_SYSTEM_PODS_ARGS=--pod-manifest-path=/etc/kubernetes/manifests --allow-privileged=true"
+Environment="KUBELET_NETWORK_ARGS=--network-plugin=cni --cni-conf-dir=/etc/cni/net.d --cni-bin-dir=/opt/cni/bin"
+Environment="KUBELET_DNS_ARGS=--cluster-dns=10.96.0.10 --cluster-domain=cluster.local"
+Environment="KUBELET_AUTHZ_ARGS=--authorization-mode=Webhook --client-ca-file=/etc/kubernetes/pki/ca.crt"
+Environment="KUBELET_CADVISOR_ARGS=--cadvisor-port=0"
+ExecStart=
+ExecStart=/usr/bin/kubelet $KUBELET_KUBECONFIG_ARGS $KUBELET_SYSTEM_PODS_ARGS $KUBELET_NETWORK_ARGS $KUBELET_DNS_ARGS $KUBELET_AUTHZ_ARGS $KUBELET_CADVISOR_ARGS $KUBELET_EXTRA_ARGS
+```
+
+A breakdown of what/why:
+
+* `--kubeconfig=/etc/kubernetes/kubelet.conf` points to the kubeconfig file that
+   tells the kubelet where the API server is. This file also has the kubelet's
+   credentials.
+* `--require-kubeconfig=true` the kubelet should fail fast if the kubeconfig file
+   is not present. This makes the kubelet crashloop during the time the service is
+   started until `kubeadm init` is run.
+* `--pod-manifest-path=/etc/kubernetes/manifests` specifies from where to read
+   Static Pod manifests used for spinning up the control plane
+* `--allow-privileged=true` allows this kubelet to run privileged Pods
+* `--network-plugin=cni` uses CNI networking
+* `--cni-conf-dir=/etc/cni/net.d` specifies where to look for the
+   [CNI spec file(s)](https://github.com/containernetworking/cni/blob/master/SPEC.md)
+* `--cni-bin-dir=/opt/cni/bin` specifies where to look for the actual CNI binaries
+* `--cluster-dns=10.96.0.10` use this cluster-internal DNS server for `nameserver`
+   entries in Pods' `/etc/resolv.conf`
+* `--cluster-domain=cluster.local` uses this cluster-internal DNS domain for
+   `search` entries in Pods' `/etc/resolv.conf`
+* `--client-ca-file=/etc/kubernetes/pki/ca.crt` authenticates requests to the Kubelet
+   API using this CA certificate.
+* `--authorization-mode=Webhook` authorizes requests to the Kubelet API by `POST`-ing
+   a `SubjectAccessReview` to the API Server
+* `--cadvisor-port=0` disables cAdvisor from listening to `0.0.0.0:4194` by default.
+   cAdvisor will still be run inside of the kubelet and its API can be accessed at
+   `https://{node-ip}:10250/stats/`. If you want to enable cAdvisor to listen on a
+   wide-open port, run:
+
+   ```
+   sed -e "/cadvisor-port=0/d" -i /etc/systemd/system/kubelet.service.d/10-kubeadm.conf
+   systemctl daemon-reload
+   systemctl restart kubelet
+   ```

 ## Cloudprovider integrations (experimental)

 Enabling specific cloud providers is a common request. This currently requires
 manual configuration and is therefore not yet fully supported. If you wish to do
-so, edit the kubeadm dropin for the kubelet service
+so, edit the kubeadm drop-in for the kubelet service
 (`/etc/systemd/system/kubelet.service.d/10-kubeadm.conf`) on all nodes,
 including the master. If your cloud provider requires any extra packages
 installed on the host, for example for volume mounting/unmounting, install those
@@ -124,7 +124,7 @@ The name **Kubernetes** originates from Greek, meaning *helmsman* or *pilot*, an

 {% capture whatsnext %}
 *   Ready to [Get Started](/docs/getting-started-guides/)?
-*   For more details, see the [Kubernetes Documentation](/docs/user-guide/).
+*   For more details, see the [Kubernetes Documentation](/docs/home/).
 {% endcapture %}
 {% include templates/concept.md %}

@@ -78,7 +78,7 @@ See the [NetworkPolicy getting started guide](/docs/getting-started-guides/netwo
 You can create a "default" isolation policy for a Namespace by creating a NetworkPolicy that selects all pods but does not allow any traffic:

 ```yaml
-apiVersion: networking/v1
+apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
  name: default-deny
@@ -91,7 +91,7 @@ This ensures that even pods that aren't selected by any other NetworkPolicy will
 Alternatively, if you want to allow all traffic for all pods in a Namespace (even if policies are added that cause some pods to be treated as "isolated"), you can create a policy that explicitly allows all traffic:

 ```yaml
-apiVersion: networking/v1
+apiVersion: networking.k8s.io/v1
 kind: NetworkPolicy
 metadata:
  name: allow-all
@@ -73,7 +73,7 @@ Let's say you want to limit access to the `nginx` service so that only pods with

 ```yaml
 kind: NetworkPolicy
-apiVersion: networking/v1
+apiVersion: networking.k8s.io/v1
 metadata:
  name: access-nginx
 spec:
@@ -84,7 +84,7 @@ webhooks.

 The structure of audit events changes when enabling the `AdvancedAuditing` feature
 flag. This includes some cleanups, such as the `method` reflecting the verb evaluated
-by the [authoriation layer](/docs/admin/authorization/) instead of the HTTP verb
+by the [authorization layer](/docs/admin/authorization/) instead of the HTTP verb
 ("create" instead of "POST"). Also, instead of always generating two events per
 request, events are recorded with an associated "stage." The known stages are:

@@ -196,7 +196,7 @@ formatted as follows:
 2017-06-15T21:50:50.259470834Z AUDIT: id="591e9fde-6a98-46f6-b7bc-ec8ef575696d" stage="ResponseComplete" ip="10.2.1.3" method="update" user="system:serviceaccount:kube-system:default" groups="\"system:serviceaccounts\",\"system:serviceaccounts:kube-system\",\"system:authenticated\"" as="<self>" asgroups="<lookup>" namespace="kube-system" uri="/api/v1/namespaces/kube-system/endpoints/kube-controller-manager" response="200"
 ```

-Logged evens omit the request and response bodies. The `Request` and
+Logged events omit the request and response bodies. The `Request` and
 `RequestResponse` levels are equivalent to `Metadata` for this backend.

 #### Webhook backend
@@ -286,4 +286,4 @@ Events are POSTed as a JSON serialized `EventList`. An example payload:

 [audit-api]: https://github.com/kubernetes/kubernetes/blob/v1.7.0-rc.1/staging/src/k8s.io/apiserver/pkg/apis/audit/v1alpha1/types.go
 [kube-apiserver]: /docs/admin/kube-apiserver
-[gce-audit-profile]: https://github.com/kubernetes/kubernetes/blob/v1.7.0-rc.1/cluster/gce/gci/configure-helper.sh#L490
+[gce-audit-profile]: https://github.com/kubernetes/kubernetes/blob/v1.7.0/cluster/gce/gci/configure-helper.sh#L490
@@ -18,13 +18,13 @@ $( document ).ready(function() {
    var forwardingRules = [{
        "from":"/docs/api-reference/v1/definitions",
        "pattern":"#_v1_(\\w+)",
-        "to":"/docs/api-reference/v1.6",
+        "to":"/docs/api-reference/v1.7",
        "postfix":"/#<token>-v1-core"
    },
    {
        "from":"/docs/user-guide/kubectl/kubectl_",
        "pattern":"kubectl_(\\w+)",
-        "to":"/docs/user-guide/kubectl/v1.6",
+        "to":"/docs/user-guide/kubectl/v1.7",
        "postfix":"/#<token>"
    },
    {