document/TranslateProject
2
0
Fork 0
mirror of https://github.com/LCTT/TranslateProject.git synced 2025-01-13 22:30:37 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'LCTT/master'

Browse Source
This commit is contained in:
Xingyu.Wang 2019-03-27 21:18:38 +08:00
commit eaf7079d95
5 changed files with 280 additions and 293 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
translated/tech/20190321 How to add new disk in Linux.md → published/20190321 How to add new disk in Linux.md
View File

@ -1,46 +1,40 @@
[#]: collector: (lujun9972)
[#]: translator: (luckyele)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: reviewer: (wxy)
[#]: publisher: (wxy)
[#]: url: (https://linux.cn/article-10658-1.html)
[#]: subject: (How to add new disk in Linux)
[#]: via: (https://kerneltalks.com/hardware-config/how-to-add-new-disk-in-linux/)
[#]: author: (kerneltalks https://kerneltalks.com)
如何在Linux中添加新磁盘
如何在 Linux 中添加新磁盘
======
* * *
_在Linux机器中逐步添加磁盘的过程_
> 在 Linux 机器中添加磁盘的逐步过程。
![New disk addition in Linux][1]
本文将向您介绍在Linux机器中添加新磁盘的步骤。将原始磁盘添加到 Linux 机器可能非常依赖于您所拥有的服务器类型，但是一旦将磁盘提供给机器，将其添加到挂载点的过程几乎相同。
本文将向你介绍在 Linux 机器中添加新磁盘的步骤。将原始磁盘添加到 Linux 机器可能非常依赖于你所拥有的服务器类型，但是一旦将磁盘提供给机器，将其添加到挂载点的过程几乎相同。
**目标** : 向服务器添加新的 10GB 磁盘，并使用 lvm 和新创建的卷组创建 5GB 装载点。
* * *
**目标**：向服务器添加新的 10GB 磁盘，并使用 lvm 和新创建的卷组创建 5GB 装载点。
### 向 Linux 机器添加原始磁盘
如果您使用的是 AWS EC2 Linux 服务器，可以 [按照以下步骤][2] 添加原始磁盘。 如果使用的是 VMware Linux VM，那么需要按照不同的步骤来添加磁盘。如果您正在运行物理机架安装/刀片服务器，那么添加磁盘将是一项物理任务。
如果你使用的是 AWS EC2 Linux 服务器，可以 [按照以下步骤][2] 添加原始磁盘。如果使用的是 VMware Linux VM，那么需要按照不同的步骤来添加磁盘。如果你正在运行物理机架设备/刀片服务器，那么添加磁盘将是一项物理任务。
一旦磁盘物理/虚拟地连接到 Linux 机器上，它将被内核识别。
* * *
一旦磁盘物理/虚拟地连接到 Linux 机器上，它将被内核识别，就可以开始了。
### 识别 Linux 最新添加的磁盘
原始磁盘连接后，需要让内核去 [扫描新磁盘][3]。在新版中，它主要是由内核自动完成。
第一件事是在内核中识别新添加的磁盘及其名称。实现这一点的方法有很多，以下作少量列举 –
第一件事是在内核中识别新添加的磁盘及其名称。实现这一点的方法有很多，以下作少量列举：
* 可以在添加/扫描磁盘前后观察 `lsblk` 输出，以获取新的磁盘名。
* 检查 `/dev` 文件系统中新创建的磁盘文件。匹配文件和磁盘添加时间的时间戳。
* 观察 `fdisk-l` 添加/扫描磁盘前后的输出，以获取新的磁盘名。
在本示例中，我使用的是 AWS EC2 服务器，向服务器添加了 5GB 磁盘。我的 lsblk 输出如下： –
在本示例中，我使用的是 AWS EC2 服务器，向服务器添加了 5GB 磁盘。我的 lsblk 输出如下：
```
[root@kerneltalks ~]# lsblk
@ -51,15 +45,13 @@ xvda 202:0 0 10G 0 disk
xvdf 202:80 0 10G 0 disk
```
可以看到 xvdf 是新添加的磁盘。完整路径是 `/dev/xvdf`。
* * *
可以看到 `xvdf` 是新添加的磁盘。完整路径是 `/dev/xvdf`。
### 在 LVM 中添加新磁盘
我们这里使用 LVM，因为它是 Linux 平台上广泛使用的非常灵活的卷管理器。确认已安装 `lvm` 或 `lvm2` [安装在系统上的程序包][4]. 如未安装，请 [安装 lvm/lvm2 程序包][5].
我们这里使用 LVM，因为它是 Linux 平台上广泛使用的非常灵活的卷管理器。确认 lvm 或 lvm2 软件包[已经安装在系统上][4]。如未安装，请 [安装 lvm/lvm2 程序包][5]。
现在，我们将在逻辑卷管理器中添加这个原始磁盘，并从中创建 10GB 的挂接点。所用到的命令如下 –
现在，我们将在逻辑卷管理器中添加这个原始磁盘，并从中创建 10GB 的挂接点。所用到的命令如下：
* [pvcreate][6]
* [vgcreate][7]
@ -67,7 +59,7 @@ xvdf 202:80 0 10G 0 disk
如果要将磁盘添加到现有挂接点，并使用其空间来[扩展挂接点][9] ，则 `vgcreate` 应替换为 `vgextend`。
会话示例输出如下： –
会话示例输出如下：
```
[root@kerneltalks ~]# pvcreate /dev/xvdf
@ -78,7 +70,7 @@ xvdf 202:80 0 10G 0 disk
Logical volume "lvdata" created.
```
现在, 已完成逻辑卷创建。您需要使用所选的文件系统格式化它，并将其载入。在这里选择ext4文件系统，并使用 `mkfs.ext4` 进行格式化。
现在，已完成逻辑卷创建。你需要使用所选的文件系统格式化它，并将其挂载。在这里选择 ext4 文件系统，并使用 `mkfs.ext4` 进行格式化。
```
[root@kerneltalks ~]# mkfs.ext4 /dev/vgdata/lvdata
@ -104,11 +96,9 @@ Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done
```
* * *
### 在挂载点上从新磁盘挂载卷
使用 `mount` 命令，在 /data 安装点上安装已创建并格式化的5GB逻辑卷。
使用 `mount` 命令，在 `/data` 安装点上安装已创建并格式化的 5GB 逻辑卷。
```
[root@kerneltalks ~]# mount /dev/vgdata/lvdata /data
@ -117,9 +107,9 @@ Filesystem Size Used Avail Use% Mounted on
/dev/mapper/vgdata-lvdata 4.8G 20M 4.6G 1% /data
```
使用df命令验证挂载点。如上所述，您都完成了！您可以在 [/etc/fstab][10] 中添加一个条目，以便在重新启动时保持此装载。
使用 `df` 命令验证挂载点。如上所述，你都完成了！你可以在 [/etc/fstab][10] 中添加一个条目，以便在重新启动时保持此装载。
您已将10GB磁盘连接到 Linux 计算机，并创建了 5GB 挂载点！
你已将 10GB 磁盘连接到 Linux 计算机，并创建了 5GB 挂载点！
--------------------------------------------------------------------------------
@ -127,8 +117,8 @@ via: https://kerneltalks.com/hardware-config/how-to-add-new-disk-in-linux/
作者：[kerneltalks][a]
选题：[lujun9972][b]
译者：[luckyele](https://github.com/luckyele/)
校对：[校对者ID](https://github.com/校对者ID)
译者：[luckyele](https://github.com/luckyele)
校对：[wxy](https://github.com/wxy)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

119
sources/talk/20180930 A Short History of Chaosnet.md
View File

@ -1,119 +0,0 @@
acyanbird translating
A Short History of Chaosnet
======
If you fire up `dig` and run a DNS query for `google.com`, you will get a response somewhat like the following:
```
$ dig google.com
; <<>> DiG 9.10.6 <<>> google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 27120
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;google.com. IN A
;; ANSWER SECTION:
google.com. 194 IN A 216.58.192.206
;; Query time: 23 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Fri Sep 21 16:14:48 CDT 2018
;; MSG SIZE rcvd: 55
```
The output contains both a section describing the “question” you asked (“What is the IP address of `google.com`?”) and a section describing the answer you received. In the answer section, we see that `dig` found a single record with what looks to be five fields. The record’s type is indicated by the `A` in the fourth field from the left—this is an “address” record. To the right of the `A`, in the fifth field, we can see that the IP address for `google.com` is `216.58.192.206`. The `194` value in the second field specifies how long in seconds this particular record can be cached.
What does the `IN` field tell us? For an embarrassingly long time, I thought `IN` functioned as a preposition, so that every DNS record was saying something like “`google.com` is in `A` and has IP address `216.58.192.206`.” It turns out that `IN` actually stands for “internet.” The `IN` part of a DNS record tells us the record’s class.
Why might a DNS record have a class other than “internet”? What would that even mean? How do you search for a host that isn’t on the internet? It would seem that `IN` is the only value that could possibly make sense here. Indeed, when you try to ask for the address of `google.com` while specifying that you expect a record with a class other than `IN`, the DNS server you are asking will probably complain. In the below, when we try to ask for the IP address of `google.com` using the `HS` class, the name server at `8.8.8.8` (Google Public DNS) returns a status of `SERVFAIL`:
```
$ dig -c HS google.com
; <<>> DiG 9.10.6 <<>> -c HS google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 31517
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;google.com. HS A
;; Query time: 34 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Tue Sep 25 14:48:10 CDT 2018
;; MSG SIZE rcvd: 39
```
So classes other than `IN` aren’t widely supported. But they do exist. In addition to `IN`, DNS records can have the `HS` class (as we’ve just seen) or the `CH` class. The `HS` class is reserved for use by a system called [Hesiod][1] that stores and distributes simple textual data using the Domain Name System. It is typically used in local environments as a stand-in for [LDAP][2]. The `CH` class is reserved for something called Chaosnet.
Today, the world belongs to TCP/IP. Those two protocols (together with UDP) govern most of the remote communication that happens between computers. But I think it’s wonderful that you can still find, hidden in the plumbing of the internet, traces of this other, long-extinct, evocatively named system. What was Chaosnet? And why did it go the way of the dinosaurs?
### A Machine Room at MIT
Chaosnet was developed in the 1970s by researchers at the MIT Artificial Intelligence Lab. It was created as a part of a larger effort to design and build a machine that could run the Lisp programming language more efficiently than a general-purpose computer.
Lisp was the brainchild of MIT professor John McCarthy, who pioneered the field of artificial intelligence. He first described Lisp to the world in [a paper][3] published in 1960. By 1962, an interpreter and a compiler had been written. Lisp introduced an astounding number of features that today we consider standard for many programming languages. It was the first language to have a garbage collector. It was the first to have a REPL. And it was the first to support dynamic typing. It found favor among programmers working in artificial intelligence and—to name just one example—was used to develop the famous [SHRDLU][4] demonstration, which allowed a human to dictate simple actions involving toy blocks to a computer in natural language.
The problem with Lisp was that it could be slow. Simple operations could take twice as long to execute as was typical with other languages because Lisp variables were type-checked at runtime and not just during compilation. Lisp’s garbage collector was known to take up to an entire second to run on the IBM 7090 at MIT. These performance issues were especially unwelcome because the AI researchers using Lisp were trying to build applications like SHRDLU that interacted with users in real time. In the late 1970s, a group of MIT Artificial Intelligence Lab researchers decided to address these problems by building machines specifically designed to run Lisp programs. These “Lisp machines” had more memory and a compact instruction set better-suited to Lisp. Type-checking would be done by dedicated circuitry, speeding it up by orders of magnitude. And unlike most computer systems at the time, Lisp machines would not be time-shared, since ambitious Lisp programs needed all the resources a computer had available. Each user would be assigned his or her own CPU. In a memo, the Lisp Machine Group at MIT described how this would make Lisp programming significantly easier:
> The Lisp Machine is a personal computer. Personal computing means that the processor and main memory are not time-division multiplexed, instead each person gets his own. The personal computation system consists of a pool of processors, each with its own main memory, and its own disk for swapping. When a user logs in, he is assigned a processor, and he has exclusive use of it for the duration of the session. When he logs out, the processor is returned to the pool, for the next person to use. This way, there is no competition from other users for memory; the pages the user is frequently referring to remain in core, and so swapping overhead is considerably reduced. Thus the Lisp Machine solves a basic problem of the time-sharing Lisp system.
The Lisp machine would be a personal computer in a different sense than the one we think of today. As the Lisp Machine Group originally envisioned it, users would sit down in their offices not in front of their own Lisp machines but in front of terminals. The terminals would be connected to the actual Lisp machine, which would be elsewhere. Even though each user would be assigned his or her own processor, the processors would still be “kept off in a machine room,” since they would make noise and take up space and thus be “unwelcome office companions.” The processors would share access to a file system and to devices like printers via a high-speed local network “with completely distributed control.” That network was Chaosnet.
Chaosnet is both a hardware standard and a software protocol. The hardware standard resembles Ethernet, and in fact the Chaosnet software protocol was eventually run over Ethernet. The software protocol, which specifies both network-layer and transport-layer interactions, was, unlike TCP/IP, always meant to govern a local network. In another memo released by the MIT Artificial Intelligence Lab, David Moon, a member of the Lisp Machine Group, explained that Chaosnet “contains no special provisions for things such as low-speed links, noisy links, multiple paths, and long-distance links with significant transit time.” The focus was instead on designing a protocol that could outperform other protocols on a small network.
Speed was important because Chaosnet sat between each Lisp processor and the file system. Network delays would significantly slow rudimentary operations like viewing the contents of a text document. To be fast enough, Chaosnet incorporated several improvements over the Network Control Program then in use on Arpanet. According to Moon, “it was important to design out bottlenecks such as are found in Arpanet, for instance the control-link which is shared between multiple connections and the need to acknowledge each message before the next message is sent.” The Chaosnet protocol batches packet acknowledgments in much the same way that TCP does today and so reduced the number of packets that needed to be transmitted by a half to a third.
Chaosnet could also get away with a relatively simple routing algorithm, since most hosts on the Lisp machine network were probably connected by a single, short wire. Moon wrote that the Chaosnet routing scheme “is predicated on the assumption that the network geometry is simple, there are few multiple paths, and the length of any path is quite short. This makes more sophisticated schemes unnecessary.” The simplicity of the algorithm meant that implementing the Chaosnet protocol was easy. The implementation program was supposedly half the size of the Arpanet Network Control Program.
The Chaosnet protocol has other idiosyncrasies. A Chaosnet address is only 16 bits, half the size of an IPv4 address, which makes sense given that Chaosnet was only ever meant to work on a local network. Chaosnet also doesn’t use port numbers; instead, a process that wants to connect to another process on a different machine first makes a connection request that specifies a target “contact name.” That contact name is often just the name of a particular service. For example, one host may try to connect to another host using the contact name `TELNET`. In practice, I assume this works more or less just like TCP, since something well-known like port 80 might as well have the contact name `HTTP`.
The Chaosnet DNS class was added to the Domain Name System by [RFC 973][5] in 1986. It replaced another class that had been available early on, the `CSNET` class, which was there to support a network called the Computer Science Network. I haven’t been able to figure out why Chaosnet was picked out for special treatment by the Domain Name System. There were other protocol families that could have been added but never were. For example, Paul Mockapetris, one of the principal architects of the Domain Name System, has written that he originally imagined that DNS would include a class for Xerox’s network protocol. That never happened. Chaosnet may have been added just because so much of the early work on Arpanet and the internet happened at Bolt, Beranek and Newman in Cambridge, Massachusetts, whose employees were often connected in some way with MIT. Chaosnet was probably well-known among the then relatively small group of people working on computer networks.
Usage of Chaosnet presumably waned as Lisp machines became less and less popular. Though Lisp machines were for a short time commercially viable products—sold by companies such as Symbolics and Lisp Machines Inc. during the 1980s—they were soon displaced by cheaper microcomputers that could run Lisp just as quickly without special-purpose circuitry. TCP/IP also fixed many of the issues with the original Arpanet protocols that Chaosnet had been created to circumvent.
### Ghost in the Shell
There unfortunately isn’t a huge amount of information still around about Chaosnet. RFC 675, which was essentially the first draft of TCP/IP, was published in 1974. Chaosnet was first developed in 1975. TCP/IP eventually conquered the world, but Chaosnet seems to have been a technological dead end. Though it’s possible that Chaosnet influenced subsequent work on TCP/IP, I haven’t found any specific examples of that happening.
The only really visible remnant of Chaosnet is the `CH` DNS class. There’s something about that fact that I find strangely fascinating. The `CH` class is a vestigial ghost of an alternative network protocol in a world that has long since settled on TCP/IP. It’s exciting, at least to me, to know that the last traces of Chaosnet still lurk out there in the infrastructure of our networked society. The `CH` DNS class is a fun artifact of digital archaeology. But it’s also a living reminder that the internet was not born fully formed, that TCP/IP is not the only way to connect computers to each other, and that “the internet” is far from the coolest name we could have had for our global communication system.
If you enjoyed this post, more like it come out every two weeks! Follow [@TwoBitHistory][6] on Twitter or subscribe to the [RSS feed][7] to make sure you know when a new post is out.
Previously on TwoBitHistory…
> Where did RSS come from? Why are there so many competing formats? Why don't people seem to use it that much anymore?
>
> Answers to these questions and many more in this week's post about RSS:<https://t.co/BsCN5GQidR>
>
> — TwoBitHistory (@TwoBitHistory) [September 17, 2018][8]
--------------------------------------------------------------------------------
via: https://twobithistory.org/2018/09/30/chaosnet.html
作者：[Two-Bit History][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://twobithistory.org
[b]: https://github.com/lujun9972
[1]: https://en.wikipedia.org/wiki/Hesiod_(name_service)
[2]: https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol
[3]: http://www-formal.stanford.edu/jmc/recursive.pdf
[4]: https://en.wikipedia.org/wiki/SHRDLU
[5]: https://tools.ietf.org/html/rfc973
[6]: https://twitter.com/TwoBitHistory
[7]: https://twobithistory.org/feed.xml
[8]: https://twitter.com/TwoBitHistory/status/1041485204802756608?ref_src=twsrc%5Etfw

143
sources/tech/20190124 What does DevOps mean to you.md
View File

@ -1,143 +0,0 @@
[#]: collector: (lujun9972)
[#]: translator: (MZqk)
[#]: reviewer: ( )
[#]: publisher: ( )
[#]: url: ( )
[#]: subject: (What does DevOps mean to you?)
[#]: via: (https://opensource.com/article/19/1/what-does-devops-mean-you)
[#]: author: (Girish Managoli https://opensource.com/users/gammay)
What does DevOps mean to you?
======
6 experts break down DevOps and the practices and philosophies key to making it work.
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/innovation_lightbulb_gears_devops_ansible.png?itok=TSbmp3_M)
It's said if you ask 10 people about DevOps, you will get 12 answers. This is a result of the diversity in opinions and expectations around DevOps—not to mention the disparity in its practices.
To decipher the paradoxes around DevOps, we went to the people who know it the best—its top practitioners around the industry. These are people who have been around the horn, who know the ins and outs of technology, and who have practiced DevOps for years. Their viewpoints should encourage, stimulate, and provoke your thoughts around DevOps.
### What does DevOps mean to you?
Let's start with the fundamentals. We're not looking for textbook answers, rather we want to know what the experts say.
In short, the experts say DevOps is about principles, practices, and tools.
[Ann Marie Fred][1], DevOps lead for IBM Digital Business Group's Commerce Platform, says, "to me, DevOps is a set of principles and practices designed to make teams more effective in designing, developing, delivering, and operating software."
According to [Daniel Oh][2], senior DevOps evangelist at Red Hat, "in general, DevOps is compelling for enterprises to evolve current IT-based processes and tools related to app development, IT operations, and security protocol."
[Brent Reed][3], founder of Tactec Strategic Solutions, talks about continuous improvement for the stakeholders. "DevOps means to me a way of working that includes a mindset that allows for continuous improvement for operational performance, maturing to organizational performance, resulting in delighted stakeholders."
Many of the experts also emphasize culture. Ann Marie says, "it's also about continuous improvement and learning. It's about people and culture as much as it is about tools and technology."
To [Dan Barker][4], chief architect and DevOps leader at the National Association of Insurance Commissioners (NAIC), "DevOps is primarily about culture. … It has brought several independent areas together like lean, [just culture][5], and continuous learning. And I see culture as being the most critical and the hardest to execute on."
[Chris Baynham-Hughes][6], head of DevOps at Atos, says, "[DevOps] practice is adopted through the evolution of culture, process, and tooling within an organization. The key focus is culture change, and the key tenants of DevOps culture are collaboration, experimentation, fast-feedback, and continuous improvement."
[Geoff Purdy][7], cloud architect, talks about agility and feedback "shortening and amplifying feedback loops. We want teams to get feedback in minutes rather than weeks."
But in the end, Daniel nails it by explaining how open source and open culture allow him to achieve his goals "in easy and quick ways. In DevOps initiatives, the most important thing for me should be open culture rather than useful tools, multiple solutions."
### What DevOps practices have you found effective?
"Picking one, automated provisioning has been hugely effective for my team. "
The most effective practices cited by the experts are pervasive yet disparate.
According to Ann Marie, "some of the most powerful [practices] are agile project management; breaking down silos between cross-functional, autonomous squads; fully automated continuous delivery; green/blue deploys for zero downtime; developers setting up their own monitoring and alerting; blameless post-mortems; automating security and compliance."
Chris says, "particular breakthroughs have been empathetic collaboration; continuous improvement; open leadership; reducing distance to the business; shifting from vertical silos to horizontal, cross-functional product teams; work visualization; impact mapping; Mobius loop; shortening of feedback loops; automation (from environments to CI/CD)."
Brent supports "evolving a learning culture that includes TDD [test-driven development] and BDD [behavior-driven development] capturing of a story and automating the sequences of events that move from design, build, and test through implementation and production with continuous integration and delivery pipelines. A fail-first approach to testing, the ability to automate integration and delivery processes and include fast feedback throughout the lifecycle."
Geoff highlights automated provisioning. "Picking one, automated provisioning has been hugely effective for my team. More specifically, automated provisioning from a versioned Infrastructure-as-Code codebase."
Dan uses fun. "We do a lot of different things to create a DevOps culture. We hold 'lunch and learns' with free food to encourage everyone to come and learn together; we buy books and study in groups."
### How do you motivate your team to achieve DevOps goals?
```
"Celebrate wins and visualize the progress made."
```
Daniel emphasizes "automation that matters. In order to minimize objection from multiple teams in a DevOps initiative, you should encourage your team to increase the automation capability of development, testing, and IT operations along with new processes and procedures. For example, a Linux container is the key tool to achieve the automation capability of DevOps."
Geoff agrees, saying, "automate the toil. Are there tasks you hate doing? Great. Engineer them out of existence if possible. Otherwise, automate them. It keeps the job from becoming boring and routine because the job constantly evolves."
Dan, Ann Marie, and Brent stress team motivation.
Dan says, "at the NAIC, we have a great awards system for encouraging specific behaviors. We have multiple tiers of awards, and two of them can be given to anyone by anyone. We also give awards to teams after they complete something significant, but we often award individual contributors."
According to Ann Marie, "the biggest motivator for teams in my area is seeing the success of others. We have a weekly playback for each other, and part of that is sharing what we've learned from trying out new tools or practices. When teams are enthusiastic about something they're doing and willing to help others get started, more teams will quickly get on board."
Brent agrees. "Getting everyone educated and on the same baseline of knowledge is essential ... assessing what helps the team achieve [and] what it needs to deliver with the product owner and users is the first place I like to start."
Chris recommends a two-pronged approach. "Run small, weekly goals that are achievable and agreed by the team as being important and [where] they can see progress outside of the feature work they are doing. Celebrate wins and visualize the progress made."
### How do DevOps and agile work together?
```
"DevOps != Agile, second Agile != Scrum."
```
This is an important question because both DevOps and agile are cornerstones of modern software development.
DevOps is a process of software development focusing on communication and collaboration to facilitate rapid application and product deployment, whereas agile is a development methodology involving continuous development, continuous iteration, and continuous testing to achieve predictable and quality deliverables.
So, how do they relate? Let's ask the experts.
In Brent's view, "DevOps != Agile, second Agile != Scrum. … Agile tools and ways of working—that support DevOps strategies and goals—are how they mesh together."
Chris says, "agile is a fundamental component of DevOps for me. Sure, we could talk about how we adopt DevOps culture in a non-agile environment, but ultimately, improving agility in the way software is engineered is a key indicator as to the maturity of DevOps adoption within the organization."
Dan relates DevOps to the larger [Agile Manifesto][8]. "I never talk about agile without referencing the Agile Manifesto in order to set the baseline. There are many implementations that don't focus on the Manifesto. When you read the Manifesto, they've really described DevOps from a development perspective. Therefore, it is very easy to fit agile into a DevOps culture, as agile is focused on communication, collaboration, flexibility to change, and getting to production quickly."
Geoff sees "DevOps as one of many implementations of agile. Agile is essentially a set of principles, while DevOps is a culture, process, and toolchain that embodies those principles."
Ann Marie keeps it succinct, saying "agile is a prerequisite for DevOps. DevOps makes agile more effective."
### Has DevOps benefited from open source?
```
"Open source done well requires a DevOps culture."
```
This question receives a fervent "yes" from all participants followed by an explanation of the benefits they've seen.
Ann Marie says, "we get to stand on the shoulders of giants and build upon what's already available. The open source model of maintaining software, with pull requests and code reviews, also works very well for DevOps teams."
Chris agrees that DevOps has "undoubtedly" benefited from open source. "From the engineering and tooling side (e.g., Ansible), to the process and people side, through the sharing of stories within the industry and the open leadership community."
A benefit Geoff cites is "grassroots adoption. Nobody had to sign purchase requisitions for free (as in beer) software. Teams found tooling that met their needs, were free (as in freedom) to modify, [then] built on top of it, and contributed enhancements back to the larger community. Rinse, repeat."
Open source has shown DevOps "better ways you can adopt new changes and overcome challenges, just like open source software developers are doing it," says Daniel.
Brent concurs. "DevOps has benefited in many ways from open source. One way is the ability to use the tools to understand how they can help accelerate DevOps goals and strategies. Educating the development and operations folks on crucial things like automation, virtualization and containerization, auto-scaling, and many of the qualities that are difficult to achieve without introducing technology enablers that make DevOps easier."
Dan notes the two-way, symbiotic relationship between DevOps and open source. "Open source done well requires a DevOps culture. Most open source projects have very open communication structures with very little obscurity. This has actually been a great learning opportunity for DevOps practitioners around what they might bring into their own organizations. Also, being able to use tools from a community that is similar to that of your own organization only encourages your own culture growth. I like to use GitLab as an example of this symbiotic relationship. When I bring [GitLab] into a company, we get a great tool, but what I'm really buying is their unique culture. That brings substantial value through our interactions with them and our ability to contribute back. Their tool also has a lot to offer for a DevOps organization, but their culture has inspired awe in the companies where I've introduced it."
Now that our DevOps experts have weighed in, please share your thoughts on what DevOps means—as well as the other questions we posed—in the comments.
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/what-does-devops-mean-you
作者：[Girish Managoli][a]
选题：[lujun9972][b]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/gammay
[b]: https://github.com/lujun9972
[1]: https://twitter.com/DukeAMO
[2]: https://twitter.com/danieloh30?lang=en
[3]: https://twitter.com/brentareed
[4]: https://twitter.com/barkerd427
[5]: https://psnet.ahrq.gov/resources/resource/1582
[6]: https://twitter.com/onlychrisbh?lang=en
[7]: https://twitter.com/geoff_purdy
[8]: https://agilemanifesto.org/

117
translated/talk/20180930 A Short History of Chaosnet.md Normal file
View File

@ -0,0 +1,117 @@
Chaosnet 简史
===
如果你输入 `dig` 命令对 `google.com` 进行 DNS 查询，你会得到如下答复：
```
$ dig google.com
; <<>> DiG 9.10.6 <<>> google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 27120
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;google.com. IN A
;; ANSWER SECTION:
google.com. 194 IN A 216.58.192.206
;; Query time: 23 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Fri Sep 21 16:14:48 CDT 2018
;; MSG SIZE rcvd: 55
```
这个输出一部分描述了你的问题（“ `google.com` 的 IP 地址是什么？），另一部分则详细解析了你收到的回答。在<ruby>答案区段<rb>ANSWER SECTION</rb></ruby>里，`dig` 为我们创造了一个包含五个字段的记录。从左数第四个字段 `A` 定义了这个记录的类型 —— 这是一个地址记录。在 `A` 的右边，第五个字段告知我们 `google.com` 的 `IP` 地址是 `216.58.192.206`。第二个字段，`194` 则代表这个记录的缓存时间是 194 秒。
那么， `IN` 字段告诉了我们什么呢？令人尴尬的是，在很长的一段时间里，我都认为这是一个介词。那时候我认为 DNS 记录大概是表达了“在 `A` 记录里，`google.com` 的 `IP` 地址是 `216.58.192.206`。”后来我才知道 `IN` 是“internet”的简写。`IN` 这一个部分告诉了我们这个记录分属的类别。
那么，除了“internet”之外，DNS 记录还会有什么别的类别吗？这究竟意味着什么？你怎么去搜寻一个不位于 internet 上的地址？看起来 `IN` 是唯一一个可能填写进这个字段的答案。而且的确，如果你尝试去获得除了 `IN` 之外的，关于 `google.com` 的记录的话，DNS 服务器通常不能给出恰当的回应。但凡事总有意外，以下就是我们尝试向 `8.8.8.8`（谷歌公共 DNS 服务器）询问在 `HS` 类别里 `google.com` 的 IP 地址。我们得到了状态为 `SERVFAIL` 的回复。
```
$ dig -c HS google.com
; <<>> DiG 9.10.6 <<>> -c HS google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 31517
;; flags: qr rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1
;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 512
;; QUESTION SECTION:
;google.com. HS A
;; Query time: 34 msec
;; SERVER: 8.8.8.8#53(8.8.8.8)
;; WHEN: Tue Sep 25 14:48:10 CDT 2018
;; MSG SIZE rcvd: 39
```
所以说，除了 `IN` 以外的类别不能被服务器广泛支持，但它们的确是存在的。除了 `IN` 之外，DNS 记录还有 `HS`（我们刚刚看到的）和 `CH` 这两个类别。`HS` 类是为一个叫做 [Hesiod][1] 的系统预留的，它可以利用 DNS 来存储并让用户访问一些文本资料。它通常在本地环境中作为 [LDAP][2] 的替代品使用。而 `CH` 这个类别，则是为 Chaosnet 技术预留的。
如今，大家都在使用 TCP/IP 协议族。这两种协议（还有 UDP）是绝大部分电脑远程连接采用的协议。不过我觉得，从互联网的垃圾堆里翻出了一个布满灰尘，绝迹已久，被人们遗忘的系统，也是一件令人愉悦的事情。那么，Chaosnet 是什么？为什么它像恐龙一样，走上了毁灭的道路呢？
### 在 MIT 的机房里
Chaosnet 是在 1970 年代，由 MIT 人工智能实验室的研究员们研发的。它是一个宏伟目标的一部分 —— 设计并制造一个能比其他电脑更高效率运行 Lisp 代码的机器。
Lisp 是 MIT 教授 John McCarthy 的造物，他亦是人工智能领域的先驱者。在 1960 年发布的[一篇论文][3]中，他首次描述了 Lisp 这个语言。在 1962 年，Lisp 的编译器和解释器诞生了。Lisp 拥有非常多的新特性。这些特性在现在看来是每一门编程语言不可或缺的一部分。它是第一门拥有垃圾回收器，REPL 和支持的动态类型的语言。在人工智能领域工作的程序员们都十分喜爱这门语言，比如说 —— 大名鼎鼎的 [SHRDLU][4] 就是用它写的。这个程序允许人们使用自然语言，向机器下达挪动玩具方块这样的命令。
Lisp 的缺点是它太慢了。跟其他语言相比，Lisp 需要使用两倍的时间来执行相同的操作。因为 Lisp 在运行中仍会检查变量类型，这一操作通常都是在编译过程中完成的。在 IBM 7090 上，它的垃圾回收器也需要长达一秒钟的时间来执行。这个问题急需解决，因为 AI 研究者们试图搭建类似 SHRDLU 的应用。他们需要程序与使用者进行实时互动。因此，在 1970 年代的晚期，MIT 人工智能研究所的研究员们决定去建造一个能更高效运行 Lisp 的机器来解决这个问题。这些“Lisp 机器”们拥有更大的存储和更小的指令集，更加适合 Lisp。类型检查由专门的回路完成，因此在 Lisp 运行速度的提升上达成了质的飞跃。跟那时流行的计算机系统不同，这些机器并不支持分时，整台电脑的资源都用来运行一个单独的 Lisp 程序。每一个用户都会得到单独的 CPU。Lisp 机器研发小组在一个备忘录里提到，这些功能是如何让 Lisp 运行变得更简单的：
>Lisp 机器是个人电脑。它支持个人编程，这意味着处理器和内存并不是分时多工的，每个人都能得到单属于自己的处理器和内存。这个私人运算系统由许多处理器组成，每个处理器都有它们自己的内存和虚拟内存。当一个用户登陆时，他就会被分配一个处理器，在他的登陆期间这个处理器是独属于他的。当他登出，这个处理器就会重新可用，等待被分配给下一个用户。通过采取这种方法，当前用户就不用和其他用户竞争内存的使用，他经常使用的信息也能保存在核心里，因此把信息调出所需要的时间也大大缩短了。这个 Lisp 机器解决了分时 Lisp 机器里产生的问题。
这个 Lisp 机器跟我们认知的现代个人电脑由很大的不同。开发小组希望今后用户不用直接面对 Lisp 机器，而是面对终端。那些终端会与位于别处的 Lisp 机器进行连接。虽然每个用户都有自己专属的处理器，但那些处理器在工作时会发出很大的噪音，因此它们最好是位于机房，而不是放在本应安静的办公室里。这些处理器会共享一个文件系统，然后通过一个“完全分布式控制”的高速本地网络访问设备，例如打印机。这个网络的名字就是 Chaosnet。
Chaosnet 既是硬件标准也是软件的协议。它的硬件标准与以太网类似，事实上软件协议也是运行在以太网之上的。这个软件协议在网络层和传输层之间交互，它并不像 TCP/IP，一直控制着本地网络。Lisp 机器开发小组的一个成员， David Moon 写的备忘录中提到，Chaosnet “目前并不打算为低速链接，噪链，多路径，长距离链接做特别的优化。”他们专注于打造一个在小型网络里表现极佳的协议。
因为 Chaosnet 连接在 Lisp 处理器和文件系统之间，所以速度十分重要。网络延迟会严重拖慢一些像打开文本文档这种简单操作的速度，为了提高速度，Chaosnet 结合了在<ruby><rb>Network Control Program</rb>网络控制程序</ruby>中使用的一些改进方法，随后的 Arpanet 项目中也使用了这些方法。根据 Moon 说过的“为了突破速率瓶颈，很有必要采纳新的设计。目前来看，瓶颈在于由多个链接分享控制链接，而且在下一个信息发送之前，我们需要知道本次信息已经送达。”Chaosnet 协议簇的 ACK 包跟当今 TCP 的差不多，它减少了 1/3 到一半的需要传输的包的数量。
因为绝大多数 Lisp 机器使用较短的单线进行连接，所以 Chaosnet 可以使用较为简单的路径算法。Moon 在 Chaosnet 路径的发展规划中写道“预计要适配的网络架构十分简单，并没有包含多少路径，而且每个节点之间的距离很短。所以我认为没有必要进行复杂的方案设计。”因为 Chaosnet 采用的算法十分简单，所以部署它也很容易。与之对比明显，Arpanet 网络控制项目的内容一半与部署有关。
Chaosnet 的另一个特性是，它的地址只有 16 bit，是 IPv4 地址的一半。所以这也意味着 Chaosnet 只能在局域网里工作。Chaosnet 也不会去使用端口号；当一个进程试图连接另一个机器上的其他进程时，需要首先初始化连接，获取一个特定的“连接名称”。这个连接名称一般是某个特定服务的名字。比方说，一个主机试图使用 `TELNET` 作为连接名称，连接另一个主机。我认为它的工作方式在实践中类似于 TCP，因为有些非常著名的服务也会拥有连接名称，比如运行在 80 端口上的 `HTTP` 服务。
在 1986 年，[RFC 973][5] 通过了将 Chaosnet DNS 类别加入域名解析系统的决议。它替代了一个早先出现的类别`CSNET` 。`CSNET` 是为了支持一个名叫计算机科学网络而被制造出来的协议。我并不知道为什么 Chaosnet 能被域名解析系统另眼相待。很多别的协议也有资格加入 DNS，但是却被忽略了。比如说 Xerox’s 网络协议，在域名解析系统的创办人之一 Paul Mockapetris 提到，在他原本的构想里这个协议应该被包括在 DNS 里。但是它并没有被加入。Chaosnet 被加入的原因大概是因为 Arpanet 项目的早期工作，有很多都在剑桥的 Bolt， Beranek 和 Newman 学院。因此研究人员和 MIT 大多有紧密的联系。在这一小撮致力于发展计算机网络人中，Chaosnet 这个协议应该较为有名。
Chaosnet 随着 Lisp 机器的衰落渐渐变得不那么流行。尽管在一小段时间内 Lisp 机器有商业应用 —— Symbolics 和 Lisp Machines Inc 在 80 年代售卖了这些机器。但它们很快被更便宜的微型计算机替代。这些计算机没有特殊制造的回路，但也可以快速运行 Lisp。Chaosnet 被制造出来的目的之一是解决一些 Apernet 协议的原始设计缺陷，但现在 TCP/IP 协议族同样能够解决这些问题了。
### 壳中幽灵
非常不幸的是，在互联网中留存的关于 Chaosnet 的资料不多。RFC 675 —— TCP/IP 的初稿于 1974 年发布，而Chasnet 于 1975 年开始开发。但 TCP/IP 最终征服了整个互联网世界，Chaosnet 则被宣布技术性死亡。尽管 Chaosnet 有可能影响了接下来 TCP/IP 的发展，可我并没有找到能够支持这个猜测的证据。
唯一一个可见的 Chaosnet 残留就是 DNS 的 `CH` 类。这个事实让我着迷。`CH` 类别是那被遗忘的幽魂 —— 在 TCP/IP 广泛部署存在的，Chaosnet 协议的最后栖身之地。至少对于我来说，这件事情是十分让人激动。它告诉我关于 Chaosnet 的最后一丝痕迹，仍然藏在我们日常使用的网络基础架构之中。DNS 的 `CH` 类别是有趣的数码考古学遗迹。但它同时也是活生生的标识，提醒着我们互联网尚未完全诞生，TCP/IP 不是唯一一个能够让计算机们交流的协议。“万维网”也远远不是我们这全球交流系统所能有的，最酷的名字。
如果你喜欢这篇文章，欢迎订阅 [RSS feed][7] 来查看最新更新。
过往文章
> RSS 是如何诞生的？ 它当时为何盛极一时，但现在鲜为人知？
>
> — TwoBitHistory (@TwoBitHistory) [September 17, 2018][8]
--------------------------------------------------------------------------------
via: https://twobithistory.org/2018/09/30/chaosnet.html
作者：[Two-Bit History][a]
选题：[lujun9972][b]
译者：[acyanbird](https://github.com/acyanbird)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://twobithistory.org
[b]: https://github.com/lujun9972
[1]: https://en.wikipedia.org/wiki/Hesiod_(name_service)
[2]: https://en.wikipedia.org/wiki/Lightweight_Directory_Access_Protocol
[3]: http://www-formal.stanford.edu/jmc/recursive.pdf
[4]: https://en.wikipedia.org/wiki/SHRDLU
[5]: https://tools.ietf.org/html/rfc973
[6]: https://twitter.com/TwoBitHistory
[7]: https://twobithistory.org/feed.xml
[8]: https://twitter.com/TwoBitHistory/status/1041485204802756608?ref_src=twsrc%5Etfw

142
translated/tech/20190124 What does DevOps mean to you.md Normal file
View File

@ -0,0 +1,142 @@
[#]: collector: "lujun9972"
[#]: translator: "MZqk"
[#]: reviewer: " "
[#]: publisher: " "
[#]: url: " "
[#]: subject: "What does DevOps mean to you?"
[#]: via: "https://opensource.com/article/19/1/what-does-devops-mean-you"
[#]: author: "Girish Managoli https://opensource.com/users/gammay"
DevOps 对你意味着什么？
======
6 位专家对 DevOps 的实现、实践关键和哲学分解。
![](https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/innovation_lightbulb_gears_devops_ansible.png?itok=TSbmp3_M)
如果你问 10 个人关于 DevOps 的问题，你会得到 12 个答案。这是对于 DevOps 意见和期望多样性的结果，更不用说它在实践中的差异。
为了解读 DevOps 的悖论，我们找到了最了解它的人 - 这个行业的顶尖从业者。这些人熟悉 DevOps，了解技术的来龙去脉，并且已经有了多年 DevOps 实践。他们的观点应该能鼓励、刺激和激发您对 DevOps 的想法。
### DevOps 对你意味着什么？
让我们从基本原理开始。我们不能只在教科书上寻找答案，而应该需要知道专家们怎么说。
简而言之，专家们说的是关于 DevOps 的原则、实践和工具。
IBM 数字企业集团 DevOps 商业平台领导者 [Ann Marie Fred][1]，说，“对于我来说，DevOps 是一套实践的原则，旨在使团队在设计，开发，交付和操作软件方面有更好的效率。”
根据红帽资深 DevOps 布道者 [Daniel Oh][2]，“ 通常来说，DevOps 促使企业基于当前的 IT 流程和工具之上发展与开发相关的应用程序 、IT 运营和安全协议。”
Tactec Strategic Solutions 的创始人 [Brent Reed][3]，就持续改进利益相关者进行了会谈。“DevOps 对我来说意味着一种工作方式，包括一种思维方式，允许持续改进运营绩效，逐渐使其成熟为组织提升绩效，从而让利益相关者高兴。”
许多专家也强调 DevOps 文化。Ann Marie 说，“这也关于持续改进和学习的问题。它涉及的是人和文化，以及工具和技术。”
美国保监会 (NAIC) 首席架构师兼 DevOps 领导者 [Dan Barker][4]，“DevOps 主要是关于文化…它将几个独立的领域聚集在一起，如精益生产、[合适文化 ][5] 和持续的学习。我认为文化是最关键和最难执行的。”
Atos 的 DevOps 负责人 [Chris Baynham-Hughes][6]，说，“[DevOps] 实践是通过组织内的文化、流程和工具的发展而被采用的。重点是文化变革，DevOps 文化借鉴的关键是协作、试验、快速反馈和持续改进。”
云架构师 [Geoff Purdy][7]，谈论敏捷和反馈，“缩短和放大反馈回路。我们希望团队在几分钟内而不是几周内获得反馈。”
但在最后，Daniel 通过解释开源和开源文化是如何让他以简单快捷的方式实现目标来强调这点，“在推动 DevOps 中，最重要的事情应该是开源文化而不是具体的工具或复杂的解决方案。”
### 你认为哪些 DevOps 实践有效？
“选择一个自动化配置，对我的团队来说非常有效。”
专家列举的那些最佳实践是普遍存在的，但又各不相同。
Ann Marie 表示：“一些十分强大灵活的项目管理[实践]，能在职能、独立的小组之间打破壁垒；全自动化持续部署，蓝/绿部署实现零时间停机状态；开发人员设置自己的监控和警告，无缝自我修复，自动化的安全性与合规性。”
Chris 说，“特别的突破是倾情合作；持续改成；开放的领导；缩短业务时长；从垂直孤岛转向横向，跨功能的产品团队。工作透明化，相互影响，Mobius 循环，缩短反馈回路，自动化（环境上的 CI/CD）。”
Brent 支持“发展学习文化，包括 TTD[ 测试驱动开发]和 BDD[ 行为驱动开发]捕获事件，并通过持续集成和持续交付从设计、构建和测试到实施在生产环境上一系列事件的自动化。测试采用故障优先的方法，能够自动化集成和交付流程，并在整个生命周期中包含快速反馈。”
Geoff 强调自动化配置。“选择一个自动化配置，对我的团队来说非常有效。更具体地说从版本控制代码库中自动配置。”
Dan uses fun。“ 我们做了很多不同的事情来建立 DevOps 文化。我们举办 ‘Lunch & Learns”’，提供免费的食物来鼓励大家一起学习。我们买书，分组学习。”
### 你如何激励你的团队实现 DevOps 这个目标？
```
"庆祝你所取得的进步。"
```
Daniel 强调“自动化的问题就是为了减少 DevOps 计划中来自多个团队的异议，您应该鼓励您的团队提高开发、测试与 IT 运营的自动化能力，以及新的流程和程序。例如，Linux 容器是实现 DevOps 自动化功能的关键工具。”
Geoff 很是赞同，“机械化的劳作，你有讨厌现在做的任务吗？很棒。如果可能的话，让它们消失。不行，那就让他们自动化。它能使工作不会变得太枯燥，因为工作总是在变化。”
Dan，Ann Marie 和 Brent 强调团队的执行力。
Dan 说，“在 NAIC，我们有个很好的奖励系统来鼓励特定的行为。我们有多个级别的奖项，其中两个奖项可以任何人颁布给某人。我们也会颁奖给完成重要任务的团队，但我们通常只奖励给个人贡献者。”
Ann Marie 表示，“我所在地区的团队最大的动力是看见其他人成功。我们每周都会彼此播放一次，其中一部分是分享我们从尝试新工具或实践中学到的东西。团队热衷于他们现在做的事情，并愿意帮助其他人开始，相信更多的团队很快也会加入进来。”
Brent 表示赞同。“让每个人学习，并掌握基础知识同样至关重要。。。。。。我喜欢从评估什么能帮助团队实现目标[以及]产品负责人和用户需要提供的内容入手。”
Chris 推荐采用双管齐下的方法。“每周运行可以实现的小目标，并且[在这]可以看到他们正在运做的功能工作之外的进展，庆祝你所取得的进步。”
### DevOps 和敏捷开发如何协同工作？
```
“DevOps ！= 敏捷。其次 敏捷 ！=Scrum流程”
```
这是一个重要的问题，因为 DevOps 和敏捷开发都是现代软件开发的基石。
DevOps 是一个软件开发的过程，专注与沟通与协作，以促进快速部署应用程序和产品。而敏捷开发是一种开发方法，涉及持续开发，连续迭代和连续测试，以实现可预测和可交付的成果质量。
那么，它们又有怎样的联系？让我们去问问专家吧。
在 Brent 来看，“DevOps！= 敏捷。其次 敏捷！=Scrum 流程。。。敏捷工具和工作方式——支撑着 DevOps 策略和目标——它们是如此融合在一起的。”
Chris 说，“对我而言敏捷是 DevOps 的一个基本组件。当然，我们可以讨论如何在非敏捷开发环境中采用 DevOps 文化，但最终表明，提高软件设计方式的灵活性是采用 DevOps 成熟读的一个关键指标。”
Dan 将 DevOps 与更伟大的[敏捷宣言 ][8] 联系起来。“我在谈到敏捷时总会引用敏捷宣言来设置基准，而有许多实现中并不关注宣言。当您阅读宣言时，您会发现它确实从开发的角度描述了 DevOps。因此，将敏捷融入 DevOps 文化非常容易，因为敏捷关注于沟通、协作、变化的灵活性以及快速地投入生产。”
Geoff 认为 “DevOps 是敏捷实施的众多实现之一。敏捷本质上是一套原则，而 DevOps 则是体现这些原则的文化、流程和工具链。”
Ann Marie 简洁说明，“敏捷是 DevOps 的先决条件。DevOps 使敏捷变得更加有效。”
### DevOps 是否受益于开源？
```
”开源做得好，需要DevOps文化。“
```
这个问题得到了所有参与者的热烈肯定，然后解释了他们看到的好处。
Ann Marie 说，”我们站在巨人的肩膀上，在已有的基础之上发展。拉取请求和代码评审的开源模式，对 DevOps 团队维护软件很有效果。“
Chris” 毫无疑问“地赞同 DevOps 受益于开源。”从设计和工具方面（例如，Ansible），到流程和人员方面，通分享行业内的故事和开源社区的领导。“
Geoff 提到一个好处是”基层的采纳“。没有人需要签署购买或申请免费（如免费啤酒）的软件。团队发现了满足他们需求的工具，可以自行（自由的）进行修改。[然后]在它之上构建，并为更大的社区提供更好的功能。如此往复。
开源已经向 DevOps 展示着”就像开源软件开发者那样做，采用更好的方式来来克服新的变化 “，Daniel 说。
Brent 同意道 ”DevOps 从开源中获益良多。一种方法是使用这些工具来理解它们是如何加速 DevOps 的目标和策略；在自动化、自动伸缩、虚拟化和容器化等关键方面对开发人员和操作人员进行培训，如果不引入使 DevOps 更加容易的技术支持，就很难实现这些特性。”
Dan 指出了 DevOps 和开源之间的双向共生关系，“做好开源需要 DevOps 文化。大多数开源项目都具有非常开放的沟通结构，很少有不透明的地方。对于 Devops 实践者来说，这实际上是一个很好的学习机会，可以让他们了解到可能需要将什么引入自己的组织中。此外能够使用来自社区与组织类似的工具来鼓励自己的文化成长。我喜欢用 GitLab 作为这种共生关系的一个例子。当我把 GitLab 带入一家公司时，我们得到了一个很棒的工具，但我们真正购买的是他们独特的文化，通过我们与他们的互动以及我们的贡献带来了巨大价值。他们的工具也可以为 Devops 组织提供更多东西，而他们的文化已经在我介绍它给的公司中引起了他们的敬畏。”
现在我们的 DevOps 专家已经参与进来了，请在评论中分享您对 DevOps 的理解，以及向我们提出其其他问题。
--------------------------------------------------------------------------------
via: https://opensource.com/article/19/1/what-does-devops-mean-you
作者：[Girish Managoli][a]
选题：[lujun9972][b]
译者：[MZqk](https://github.com/MZqk)
校对：[校对者ID](https://github.com/校对者ID)
本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
[a]: https://opensource.com/users/gammay
[b]: https://github.com/lujun9972
[1]: https://twitter.com/DukeAMO
[2]: https://twitter.com/danieloh30?lang=en
[3]: https://twitter.com/brentareed
[4]: https://twitter.com/barkerd427
[5]: https://psnet.ahrq.gov/resources/resource/1582
[6]: https://twitter.com/onlychrisbh?lang=en
[7]: https://twitter.com/geoff_purdy
[8]: https://agilemanifesto.org/