How is Kubernetes (k8s) different from Docker?

The question “Kubernetes vs. Docker?” in itself is rather absurd, like comparing apples to oranges. One isn’t an alternative to the other. Quite the contrary, Kubernetes can run without Docker and Docker can function without Kubernetes. But Kubernetes can (and does) benefit greatly from Docker and vice versa.

• question：问题
• rather：相当
• absurd：荒谬的
• like：像
• comparing：比较
• apples：苹果
• oranges：橙子
• alternative：替代品
• one：一个
• isn't：不是
• another：另一个
• quite：相当
• contrary：相反的
• can：可以
• run：运行
• without：没有
• function：工作
• benefit：获益
• greatly：极大地
• from：从...中
• vice versa：反之亦然

Docker is a standalone application which can be installed on any computer to run containerized applications. Containerization is an approach of running applications on an OS such that the application is isolated from the rest of the system. You create an illusion for your application that it is getting its very own OS instance, although there may be other containers running on the same system. Docker is what enables us to run, create and manage containers on a single operating system.

• Docker：Docker（容器化平台的名称）。
• standalone：独立的。
• application：应用程序。
• installed：安装。
• computer：计算机。
• run：运行。
• containerized：容器化的。
• applications：应用程序。
• Containerization：容器化。
• approach：方法。
• running：运行。
• isolated：隔离的。
• rest：其余部分。
• system：系统。
• create：创建。
• illusion：假象。
• getting：得到。
• very own：自己的。
• OS instance：操作系统实例。
• other：其他。
• containers：容器。
• enables：使能够。
• us：我们。
• manage：管理。
• single：单个。
• operating system：操作系统。

Kubernetes turns it up to eleven. If you have Docker installed on a bunch of hosts (different operating systems), you can leverage Kubernetes. These nodes or Docker hosts can be bare metal servers or virtual machines. Kubernetes can then allow you to automate container provisioning, networking, load-balancing, security and scaling across all these nodes from a single command-line or dashboard. A collection of nodes that are managed by a single Kubernetes instance is referred to as a Kubernetes cluster.

• Kubernetes：Kubernetes（容器编排平台的名称）。
• turns it up to eleven：将其提升到更高级别（表示 Kubernetes 是高级的容器编排工具）。
• installed：安装。
• bunch：一堆。
• hosts：主机。
• different：不同的。
• operating systems：操作系统。
• leverage：利用。
• nodes：节点。
• Docker hosts：Docker 主机。
• bare metal：裸机（指裸机服务器，没有虚拟化层的服务器）。
• servers：服务器。
• virtual machines：虚拟机。
• allow：允许。
• automate：自动化。
• container provisioning：容器配置。
• networking：网络。
• load-balancing：负载均衡。
• security：安全性。
• scaling：扩展。
• across：跨越。
• single：单个。
• command-line：命令行。
• dashboard：仪表板。
• collection：集合。
• managed by：由...管理。
• instance：实例。
• referred to as：称为。
• cluster：集群。

Now, why would you need to have multiple nodes in the first place? The two main motivations behind it are:

• need：需要。
• multiple：多个。
• nodes：节点。
• first place：首先。
• two：两个。
• main：主要的。
• motivations：动机。
• behind：背后的。

To make the infrastructure more robust — Your application will be online, even if some of the nodes go offline, i.e, High Availability. To make your application more scalable — If workload increases simply spawn more containers and/or add more nodes to your Kubernetes cluster. “Kubernetes automates the process of scaling, managing, updating and removing containers. In other words, it is a container orchestration platform. While Docker is at the heart of the containerization, it enables us to have containers in the first place.

• To make：为了使。
• infrastructure：基础设施。
• more robust：更加健壮。
• Your application：您的应用程序。
• online：在线。
• even if：即使。
• some：一些。
• go offline：下线。
• i.e.：即，即是（拉丁语缩写，表示 "that is"，即 "也就是说"）。
• High Availability：高可用性。
• scalable：可扩展。
• workload：工作负载。
• increases：增加。
• simply：简单地。
• spawn：生成。
• containers：容器。
• and/or：和/或（用于表示 "和" 或 "或" 的组合）。
• add：添加。
• nodes：节点。
• Kubernetes cluster：Kubernetes 集群。
• automates：自动化。
• process：过程。
• scaling：扩展。
• managing：管理。
• updating：更新。
• removing：删除。
• container orchestration platform：容器编排平台。
• While：虽然。
• Docker：Docker（容器化平台的名称）。
• at the heart of：在...的核心。
• containerization：容器化。
• enables：使能够。
• have：拥有。
• containers：容器。

In principle, Kubernetes can work with any containerization technology. Two of the most popular options that Kubernetes can integrate with are rkt and Docker. However, Docker has won the greatest market segment and that has led to a lot of effort in perfecting the integration between Docker and Kubernetes, more than any other containerization technology.

• In principle：原则上。
• Kubernetes：Kubernetes（容器编排平台的名称）。
• can work with：可以与...一起使用。
• any：任何。
• containerization technology：容器化技术。
• Two of the most popular options：最流行的两种选项。
• integrate with：与...集成。
• are：是。
• rkt：rkt（一种容器运行时）。
• Docker：Docker（容器化平台的名称）。
• However：然而。
• has won：赢得。
• the greatest：最大的。
• market segment：市场份额。
• that has led to：导致了。
• a lot of：许多。
• effort：努力。
• perfecting：完善。
• the integration between：在...之间的集成。
• more than：超过。
• any other：任何其他。

Similarly, Docker Inc., the company behind Docker, offers their own container orchestration engine, named Docker Swarm. But even they realized the fact that Kubernetes has risen to the point that even Docker for Desktop (MacOS and Windows) comes with its own Kubernetes distribution.

• Similarly：同样地。
• Docker Inc.：Docker 公司（Docker 背后的公司）。
• the company behind：背后的公司。
• offers：提供。
• their own：他们自己的。
• container orchestration engine：容器编排引擎。
• named：命名为。
• Docker Swarm：Docker Swarm（Docker 提供的容器编排工具）。
• But even：但即使。
• they realized：他们意识到。
• the fact that：事实是。
• has risen to the point：已经崭露头角。
• that even：以至于即使。
• Docker for Desktop：Docker for Desktop（用于 MacOS 和 Windows 的 Docker 版本）。
• comes with：附带。
• its own：自己的。
• Kubernetes distribution：Kubernetes 发行版。

If anyone was nervous about adopting Kubernetes for their Docker-based product, that last point would get rid of all of the doubts. Both projects have wholeheartedly embraced each other and have benefited tremendously from this symbiosis.

• If anyone：如果有人。
• was nervous about：对...感到紧张。
• adopting：采用。
• Kubernetes：Kubernetes（容器编排平台的名称）。
• for their：为他们的。
• Docker-based product：基于 Docker 的产品。
• that last point：最后一点。
• would get rid of：将消除。
• all of the：所有的。
• doubts：疑虑。
• Both：两者都。
• projects：项目。
• have wholeheartedly embraced：全力拥抱。
• each other：彼此。
• and have benefited tremendously from：并从中获得了巨大的好处。
• this symbiosis：这种共生关系。

These projects are more than technologies, they are a community of people, who, despite their differences, are is composed of some of the brightest minds in the industry. When like-minded individuals collaborate, they exchange bright ideas and learn best practices from one another.

These are some of such ideas that both, Kubernetes and Docker, share:

• These projects：这些项目。
• are more than：不仅仅是。
• technologies：技术。
• they are：它们是。
• a community of people：一群人的社区。
• who：谁。
• despite their differences：尽管他们之间存在差异。
• is composed of：由...组成。
• some of the brightest minds：一些最杰出的思想。
• in the industry：在该行业中。
• When：当。
• like-minded：志同道合的。
• individuals：个体。
• collaborate：合作。
• they exchange：他们交流。
• bright ideas：睿智的思想。
• and learn：并从中学习。
• best practices：最佳实践。
• from one another：从彼此那里学习。

Their love for microservice based architecture (more on this later). Their love for open source community. Both are largely open source projects. They are largely written in Go which allows them to be shipped as small lightweight binaries. They use human-readable YAML files to specify application stacks and their deployments. In theory, you can learn about one without having a clue about the other. But keep in mind that in practice you will benefit a lot more if you start with the simple case of Docker running on a single machine, and then gradually understand how Kubernetes comes into play.

• Their love for：他们对...的热爱。
• microservice based architecture：微服务架构。
• more on this later：稍后详细介绍。
• open source community：开源社区。
• Both are largely：它们都是大规模的。
• largely written in：主要用...编写。
• Go：Go 语言（一种编程语言）。
• allows them to be：使它们能够。
• shipped as：作为...进行发布。
• small lightweight binaries：小型轻量级二进制文件。
• use：使用。
• human-readable：人类可读的。
• YAML files：YAML 文件。
• specify：指定。
• application stacks：应用程序堆栈。
• deployments：部署。
• In theory：从理论上讲。
• you can learn about：您可以了解有关...的信息。
• one without：一个而没有。
• having a clue about：一无所知。
• But keep in mind that：但请记住。
• in practice：在实践中。
• you will benefit a lot more：您将获益更多。
• if you start with：如果您从...开始。
• the simple case of：简单情况。
• Docker running on：在...上运行 Docker。
• a single machine：单台机器。
• gradually understand：逐渐了解。
• comes into play：起作用。

Containers are amazing! They allow us to think about services and systems in a completely new and digital way. Both Docker and Kubernetes are here to stay. They are continuously changing to transform themselves into something better in the future. Keep your company involved in the Technology era and implement the containers that your infrastructure needs the most.

• Containers：容器。
• are amazing：令人惊奇。
• They allow us to：它们使我们能够。
• think about：思考。
• services and systems：服务和系统。
• in a completely new and digital way：以全新的数字方式。
• Both：两者都。
• here to stay：将继续存在。
• They are continuously changing：它们正在不断变化。
• to transform themselves into：将自己转变为。
• something better in the future：未来更好的东西。
• Keep your company involved in：让您的公司参与。
• the Technology era：科技时代。
• implement：实施。
• the containers：容器。
• that your infrastructure needs：您的基础设施最需要的。

Designing newer software for a container-centric platform would not only make your apps more scalable but also more future-proof. Sticking to the old VMs might work for now, but a few years down the line you will eventually have to either bear the heavy cost of migrating everything into containers or abandon your projects altogether. Hopefully, now if someone brings up the topic of “Kubernetes vs Docker” you won’t get swept away by jargons.

• Designing newer software for：为...设计新的软件。
• a container-centric platform：一个以容器为中心的平台。
• would not only：不仅仅会。
• make your apps more scalable：使您的应用程序更具可扩展性。
• but also：而且。
• more future-proof：更具未来可塑性。
• Sticking to：坚持使用。
• insight: 理解
• the old VMs：旧的虚拟机。
• might work for now：可能暂时有效。
• but a few years down the line：但几年后。
• you will eventually have to：最终将不得不。
• either bear the heavy cost of：承担巨大的成本。
• migrating everything into containers：将所有内容迁移到容器中。
• or abandon your projects altogether：或者完全放弃您的项目。
• Hopefully：希望。
• now if someone brings up：现在如果有人提出。
• the topic of：...的话题。
• won't get swept away by jargons：不会被术语所迷惑。

This is a question from Quora.

Is going to college for computer science with a focus of software engineering still worth it in 2023? I just finished my freshman year of college.

• college: 大学
• computer science: 计算机科学
• focus: 专注
• software engineering: 软件工程
• worth it: 值得
• 2023: 2023年
• freshman year: 大一

You have three choices:

1.Continue in computer science.

2.Change to a different major.

3.Drop out of college.

Each of these carries risk and potential rewards. If you're only pursuing CS because you dream of making $150k

right after graduating college, I think you should choose something else. The market has shifted and that was not a sustainable reality. I warned that it would come to an end. There will be great opportunities, but making $300k 3–4 years out of college will be reserved for exceptional talent.

But if you stay, you will get a solid education that balances theory and practice. I don't know what the job market will look like in two years when you start applying for post-grad jobs, but there will be computing jobs.

• Continue: 继续
• Computer Science: 计算机科学
• Change: 改变
• Different: 不同的
• Major: 专业
• Drop out: 辍学
• College: 大学
• Carries: 带有
• Risk: 风险
• Potential: 潜在的
• Rewards: 奖励
• Pursuing: 追求
• Dream: 梦想
• Graduating: 毕业
• Sustainable: 可持续的
• Reality: 现实
• Market: 市场
• Shifted: 转变
• Warned: 警告
• End: 结束
• Opportunities: 机会
• Reserved: 保留
• Exceptional: 出色的
• Talent: 才能
• Stay: 留下
• Solid: 坚实的
• Education: 教育
• Balances: 平衡
• Theory: 理论
• Practice: 实践
• Job market: 就业市场
• Two years: 两年
• Start: 开始
• Applying: 申请
• Post-grad: 研究生毕业后的
• Computing jobs: 计算机相关工作

This is a question from Quora.

As a computer science educator if you can teach only one thing to your students what would it be?

• Computer Science: 计算机科学
• Educator: 教育者
• Teach: 教授
• One: 一
• Thing: 事物
• Student: 学生
• What: 什么
• Would: 将会
• It: 它
• Be: 存在/是

Algorithmic thinking. There's a lot that underlies that, but you fundamentally need to be able to learn how to break problems down in to smaller solvable tasks, and apply tightly constrained instructions to solve those tasks. The rest is just syntactic sugar and math. Really, really important math.

• Algorithmic: 算法的
• Thinking: 思维
• Underlies: 构成...的基础
• Fundamentally: 基本上
• Need: 需要
• Learn: 学习
• Break down: 分解
• Problems: 问题
• Smaller: 更小的
• Solvable: 可解决的
• Tasks: 任务
• Apply: 应用
• Tightly constrained: 严格限定的
• Instructions: 指令
• Rest: 其余部分
• Syntactic sugar: 语法糖
• Math: 数学

I want to teach my students how to fail. Part of learning to fail is simple programming practice. It's fundiversión to write code, and the temptation is to write dozens of lines of code at a time. It's much less fun to debug code, and when your dozens of lines fails in strange ways you've made your life far more difficult than it needs to be. So take baby steps: write the smallest number of lines that can be tested, then stop and test it. That code will fail, too, but debugging it will be a relatively pain-free process and you get the psychological boost of solving lots of small failures relatively quickly.

• teach (教)
• students (学生)
• fail (失败)
• relatively (相对的)
• learning (学习)
• much less (更不用说)
• programming practice (编程实践)
• write code (编写代码)
• dozens of lines (几十行代码)
• debug code (调试代码)
• strange ways (奇怪的方式)
• difficult (困难)
• baby steps (小步骤)
• smallest number of lines (最少的代码行数)
• test (测试)
• pain-free (相对轻松的)
• process (过程)
• psychological boost (心理推动)
• solve (解决)
• small failures (小失败)
• quickly (迅速)

Source control also has a role to play here. If you commit often, you can occasionally take larger risks secure in knowing that if it doesn't work out, one command will bring you back to a known state.

• source control (版本控制)
• role (角色，作用)
• commit often (经常提交)
• larger risks (较大的风险)
• secure (安心)
• one command (一个命令)
• bring back (还原)
• known state (已知状态)

The deeper lesson is divorcing code that fails from the feeling of failure. If your code X produced state Y and you wanted state Z, and you take this personally, you're in for a long semester. If, on the other hand, I can convince you that you've now learned something you didn't know before about code X, then you're much less likely to feel helpless. If you're not feeling helpless, it's a lot easier to try something different and eventually (after visiting states P, D, Q, and aleph-1) getting to Z.

• divorcing (分离)
• code that fails (失败的代码)
• feeling of failure (失败的感觉)
• lesson (教训)
• personally (个人地)
• easier (小心的)
• long semester (漫长的学期)
• learned something (学到了一些东西)
• feel helpless (感到无助)
• try something different (尝试不同的方法)
• eventually (最终)
• visiting states (经历状态)
• getting to Z (达到状态 Z)

Once you've learned how to do controlled failures and divorce programming failure from the emotion of failure, programming starts to become pretty enjoyable and your learning rate goes up by an order of magnitude.

• controlled failures (可控的失败)
• divorce programming failure (将编程失败分离开来)
• emotion of failure (失败的情绪)
• programming (编程)
• enjoyable (有乐趣的)
• learning rate (学习速度)
• an order of magnitude (一个数量级)

c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

什么时候POST请求会发送两次？

以下是可能导致POST请求发送两次的一些原因：

1. 重复提交：用户可能在提交表单或发送POST请求时多次点击提交按钮或发送请求的操作，导致请求被发送多次。

2. 页面刷新：当用户在提交POST请求后刷新页面时，某些浏览器会尝试重新发送之前的POST请求，以便用户可以重新加载页面并继续之前的操作。

3. 跨域请求：在某些情况下，如果你的网页中存在跨域请求，浏览器可能会发送OPTIONS请求进行预检（preflight），然后再发送实际的POST请求。这样就会导致看起来像是发送了两次POST请求，但实际上第一个请求是OPTIONS请求。

4. 重定向：如果服务器返回一个重定向响应（例如状态码为302），浏览器可能会自动跟随重定向并发送第二个POST请求。

5. 缓存问题：一些缓存机制可能会导致POST请求被重复发送。例如，浏览器或代理服务器可能会缓存POST请求的响应，然后在后续请求时重用缓存的响应，从而导致看起来像是发送了两次POST请求。

以下是一些常见的解决方法：

• 在前端代码中，可以通过禁用提交按钮或在提交请求后禁用表单来防止用户多次点击提交按钮。
• 在服务器端，可以使用幂等性来处理重复请求，确保多次相同的POST请求不会产生不一致的结果。
• 如果是跨域请求导致的问题，可以在服务器端进行相应的配置，允许跨域请求或使用CORS（跨源资源共享）机制进行处理。
• 如果是缓存问题，可以在服务器端设置适当的缓存控制头，以确保POST请求不会被缓存或缓存的时间较短。

根据具体的情况，你可能需要进一步调查并采取适当的解决措施来处理重复发送的POST请求。

什么是浏览器同源策略？

同源策略（Same-Origin Policy）是一种浏览器安全机制，用于限制在浏览器中加载的网页脚本与来自不同源（即不同的域、协议或端口）的资源之间的交互操作。它是为了保护用户的隐私和安全而设计的。

同源策略的基本原则是，当一个网页脚本尝试访问另一个源的资源时，浏览器会阻止这种跨源的操作，以防止恶意网站利用跨域请求获取用户的敏感信息或对其他网站进行攻击。

同源策略的限制主要包括以下几个方面：

1. 域名：同源策略要求两个网页具有相同的域名（协议、主机和端口），即使两个域名只是在协议、主机或端口上稍有不同，也会被视为不同源。例如，http://example.com 和 https://example.com 被视为不同源。

2. Cookie、LocalStorage 和 IndexDB：同源策略限制了对跨源的 Cookie、LocalStorage 和 IndexDB 的访问。这意味着网页脚本只能访问属于同一源的 Cookie 和存储数据，而无法读取或修改其他源的数据。

3. DOM 访问：同源策略限制了对跨源文档对象模型（DOM）的访问。网页脚本只能修改属于同一源的 DOM 元素，无法直接访问或修改其他源的 DOM。

4. XMLHttpRequest 和 Fetch 请求：同源策略对跨源的 XMLHttpRequest 和 Fetch 请求进行限制。通常情况下，这些请求只能向同源发起，无法直接访问其他源的数据。

为了允许跨域请求，浏览器引入了一些机制，如跨域资源共享（CORS）和服务器代理。这些机制允许服务器通过设置适当的响应头来授权特定的跨域请求。

同源策略在保护用户隐私和安全方面起着重要的作用，防止恶意网站滥用用户的信息。然而，有时候需要进行跨域操作，因此开发人员需要了解和遵守跨域规则，并使用适当的跨域解决方案。

什么是预请求？

预请求（Preflight Request）是在进行跨域资源共享（CORS）时，某些特定情况下由浏览器自动发送的一种HTTP请求。它是一个OPTIONS请求，用于在实际的跨域请求之前进行预检，以确定是否允许实际请求的发送。

在以下情况下，浏览器会发送预请求：

1. 跨域请求：当浏览器发起跨域请求时，即请求的目标与当前页面的域名、协议或端口不一致时，浏览器会发送预请求。

2. 自定义请求头：如果在跨域请求中使用了特定的自定义请求头（例如Content-Type、Authorization等），并且这些请求头属于 "CORS安全列表" 之外的请求头，浏览器也会发送预请求。

预请求的目的是为了确保服务器支持跨域请求并允许浏览器发送实际的跨域请求。预请求的发送和处理过程如下：

1. 发送预请求：浏览器在发送实际的跨域请求之前，先发送一个OPTIONS请求，其中包含了一些额外的头部信息，如Origin（指示请求的源）和Access-Control-Request-Method（指示实际请求的方法）等。

2. 服务器处理预请求：服务器接收到预请求后，进行预检查。它会检查请求的源是否在允许的跨域列表中，以及是否允许实际请求的方法、请求头等。

3. 响应预请求：服务器根据预检查的结果，返回包含了对应的响应头信息的响应。响应头中重要的字段是Access-Control-Allow-Origin（指示允许的源）和Access-Control-Allow-Methods（指示允许的方法）等。

4. 浏览器处理预请求响应：浏览器接收到预请求的响应后，会检查响应头中的相关字段，以确定是否允许发送实际的跨域请求。

5. 发送实际请求：如果预请求的响应表明服务器允许实际请求，浏览器会发送实际的跨域请求，其中包含了实际的请求方法、请求头等。

需要注意的是，预请求是由浏览器自动发送的，并且在实际请求之前进行。它的目的是为了提供一种机制，确保服务器允许跨域请求，以增加安全性。服务器需要正确地处理预请求并返回适当的响应头，以允许或拒绝实际的跨域请求。

总结

预请求就是浏览器在进行跨域请求访问时向目标浏览器发送的一个预检测请求，检测目标服务器是否支持跨域请求，预请求是一个OPTIONS请求，其中包含了一些额外的头部信息，如Origin（请求源）、Access-Control-Request-Method（实际请求的方法）和Access-Control-Request-Headers（实际请求的头部信息）。服务器收到预请求后，可以检查这些头部信息，并决定是否允许实际的跨域请求。

服务器在收到预请求后，可以通过设置响应头部中的Access-Control-Allow-Origin、Access-Control-Allow-Methods和Access-Control-Allow-Headers等字段来指定允许的跨域请求来源、方法和头部信息。如果服务器确认允许跨域请求，浏览器会继续发送实际的跨域请求，否则将阻止实际请求的发送，并返回相应的错误。

预请求机制的目的是确保服务器允许跨域请求，并在发送实际请求之前进行验证，从而保护用户的隐私和安全。开发人员需要在服务器上正确地配置CORS头部信息，以便处理预请求，并允许必要的跨域请求。

实践，gin设置支持跨域请求

1.通过自定义中间件

package main

import (
	"github.com/gin-gonic/gin"
)

func main() {
	// 创建 Gin 引擎
	router := gin.Default()

	// 添加跨域请求的中间件
	router.Use(corsMiddleware())

	// 添加你的路由处理逻辑

	// 启动服务器
	router.Run(":8080")
}

// 跨域请求中间件
func corsMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		// 设置允许的请求来源
		c.Writer.Header().Set("Access-Control-Allow-Origin", "http://example.com")

		// 设置允许的请求方法
		c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE")

		// 设置允许的请求头部信息
		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization")

		// 设置是否允许发送凭据
		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")

		// 如果是预请求（OPTIONS请求），则直接返回
		if c.Request.Method == "OPTIONS" {
			c.AbortWithStatus(204)
			return
		}

		// 继续处理实际的请求
		c.Next()
	}
}

2.官方推荐跨域请求中间件，具体可以看官方示例代码