天道酬勤,学无止境

How do multiple clients connect simultaneously to one port, say 80, on a server? [duplicate]

I understand the basics of how ports work. However, what I don't get is how multiple clients can simultaneously connect to say port 80. I know each client has a unique (for their machine) port. Does the server reply back from an available port to the client, and simply state the reply came from 80? How does this work?

评论

First off, a "port" is just a number. All a "connection to a port" really represents is a packet which has that number specified in its "destination port" header field.

Now, there are two answers to your question, one for stateful protocols and one for stateless protocols.

For a stateless protocol (ie UDP), there is no problem because "connections" don't exist - multiple people can send packets to the same port, and their packets will arrive in whatever sequence. Nobody is ever in the "connected" state.

For a stateful protocol (like TCP), a connection is identified by a 4-tuple consisting of source and destination ports and source and destination IP addresses. So, if two different machines connect to the same port on a third machine, there are two distinct connections because the source IPs differ. If the same machine (or two behind NAT or otherwise sharing the same IP address) connects twice to a single remote end, the connections are differentiated by source port (which is generally a random high-numbered port).

Simply, if I connect to the same web server twice from my client, the two connections will have different source ports from my perspective and destination ports from the web server's. So there is no ambiguity, even though both connections have the same source and destination IP addresses.

Ports are a way to multiplex IP addresses so that different applications can listen on the same IP address/protocol pair. Unless an application defines its own higher-level protocol, there is no way to multiplex a port. If two connections using the same protocol simultaneously have identical source and destination IPs and identical source and destination ports, they must be the same connection.

Important:

I'm sorry to say that the response from "Borealid" is imprecise and somewhat incorrect - firstly there is no relation to statefulness or statelessness to answer this question, and most importantly the definition of the tuple for a socket is incorrect.

First remember below two rules:

  1. Primary key of a socket: A socket is identified by {SRC-IP, SRC-PORT, DEST-IP, DEST-PORT, PROTOCOL} not by {SRC-IP, SRC-PORT, DEST-IP, DEST-PORT} - Protocol is an important part of a socket's definition.

  2. OS Process & Socket mapping: A process can be associated with (can open/can listen to) multiple sockets which might be obvious to many readers.

Example 1: Two clients connecting to same server port means: socket1 {SRC-A, 100, DEST-X,80, TCP} and socket2{SRC-B, 100, DEST-X,80, TCP}. This means host A connects to server X's port 80 and another host B also connects to same server X to the same port 80. Now, how the server handles these two sockets depends on if the server is single threaded or multiple threaded (I'll explain this later). What is important is that one server can listen to multiple sockets simultaneously.

To answer the original question of the post:

Irrespective of stateful or stateless protocols, two clients can connect to same server port because for each client we can assign a different socket (as client IP will definitely differ). Same client can also have two sockets connecting to same server port - since such sockets differ by SRC-PORT. With all fairness, "Borealid" essentially mentioned the same correct answer but the reference to state-less/full was kind of unnecessary/confusing.

To answer the second part of the question on how a server knows which socket to answer. First understand that for a single server process that is listening to same port, there could be more than one sockets (may be from same client or from different clients). Now as long as a server knows which request is associated with which socket, it can always respond to appropriate client using the same socket. Thus a server never needs to open another port in its own node than the original one on which client initially tried to connect. If any server allocates different server-ports after a socket is bound, then in my opinion the server is wasting its resource and it must be needing the client to connect again to the new port assigned.

A bit more for completeness:

Example 2: It's a very interesting question: "can two different processes on a server listen to the same port". If you do not consider protocol as one of parameter defining socket then the answer is no. This is so because we can say that in such case, a single client trying to connect to a server-port will not have any mechanism to mention which of the two listening processes the client intends to connect to. This is the same theme asserted by rule (2). However this is WRONG answer because 'protocol' is also a part of the socket definition. Thus two processes in same node can listen to same port only if they are using different protocol. For example two unrelated clients (say one is using TCP and another is using UDP) can connect and communicate to the same server node and to the same port but they must be served by two different server-processes.

Server Types - single & multiple:

When a server's processes listening to a port that means multiple sockets can simultaneously connect and communicate with the same server-process. If a server uses only a single child-process to serve all the sockets then the server is called single-process/threaded and if the server uses many sub-processes to serve each socket by one sub-process then the server is called multi-process/threaded server. Note that irrespective of the server's type a server can/should always uses the same initial socket to respond back (no need to allocate another server-port).

Suggested Books and rest of the two volumes if you can.

A Note on Parent/Child Process (in response to query/comment of 'Ioan Alexandru Cucu')

Wherever I mentioned any concept in relation to two processes say A and B, consider that they are not related by parent child relationship. OS's (especially UNIX) by design allow a child process to inherit all File-descriptors (FD) from parents. Thus all the sockets (in UNIX like OS are also part of FD) that a process A listening to, can be listened by many more processes A1, A2, .. as long as they are related by parent-child relation to A. But an independent process B (i.e. having no parent-child relation to A) cannot listen to same socket. In addition, also note that this rule of disallowing two independent processes to listen to same socket lies on an OS (or its network libraries) and by far it's obeyed by most OS's. However, one can create own OS which can very well violate this restrictions.

TCP / HTTP Listening On Ports: How Can Many Users Share the Same Port

So, what happens when a server listen for incoming connections on a TCP port? For example, let's say you have a web-server on port 80. Let's assume that your computer has the public IP address of 24.14.181.229 and the person that tries to connect to you has IP address 10.1.2.3. This person can connect to you by opening a TCP socket to 24.14.181.229:80. Simple enough.

Intuitively (and wrongly), most people assume that it looks something like this:

    Local Computer    | Remote Computer
    --------------------------------
    <local_ip>:80     | <foreign_ip>:80

    ^^ not actually what happens, but this is the conceptual model a lot of people have in mind.

This is intuitive, because from the standpoint of the client, he has an IP address, and connects to a server at IP:PORT. Since the client connects to port 80, then his port must be 80 too? This is a sensible thing to think, but actually not what happens. If that were to be correct, we could only serve one user per foreign IP address. Once a remote computer connects, then he would hog the port 80 to port 80 connection, and no one else could connect.

Three things must be understood:

1.) On a server, a process is listening on a port. Once it gets a connection, it hands it off to another thread. The communication never hogs the listening port.

2.) Connections are uniquely identified by the OS by the following 5-tuple: (local-IP, local-port, remote-IP, remote-port, protocol). If any element in the tuple is different, then this is a completely independent connection.

3.) When a client connects to a server, it picks a random, unused high-order source port. This way, a single client can have up to ~64k connections to the server for the same destination port.

So, this is really what gets created when a client connects to a server:

    Local Computer   | Remote Computer           | Role
    -----------------------------------------------------------
    0.0.0.0:80       | <none>                    | LISTENING
    127.0.0.1:80     | 10.1.2.3:<random_port>    | ESTABLISHED

Looking at What Actually Happens

First, let's use netstat to see what is happening on this computer. We will use port 500 instead of 80 (because a whole bunch of stuff is happening on port 80 as it is a common port, but functionally it does not make a difference).

    netstat -atnp | grep -i ":500 "

As expected, the output is blank. Now let's start a web server:

    sudo python3 -m http.server 500

Now, here is the output of running netstat again:

    Proto Recv-Q Send-Q Local Address           Foreign Address         State  
    tcp        0      0 0.0.0.0:500             0.0.0.0:*               LISTEN      - 

So now there is one process that is actively listening (State: LISTEN) on port 500. The local address is 0.0.0.0, which is code for "listening for all". An easy mistake to make is to listen on address 127.0.0.1, which will only accept connections from the current computer. So this is not a connection, this just means that a process requested to bind() to port IP, and that process is responsible for handling all connections to that port. This hints to the limitation that there can only be one process per computer listening on a port (there are ways to get around that using multiplexing, but this is a much more complicated topic). If a web-server is listening on port 80, it cannot share that port with other web-servers.

So now, let's connect a user to our machine:

    quicknet -m tcp -t localhost:500 -p Test payload.

This is a simple script (https://github.com/grokit/dcore/tree/master/apps/quicknet) that opens a TCP socket, sends the payload ("Test payload." in this case), waits a few seconds and disconnects. Doing netstat again while this is happening displays the following:

    Proto Recv-Q Send-Q Local Address           Foreign Address         State  
    tcp        0      0 0.0.0.0:500             0.0.0.0:*               LISTEN      -
    tcp        0      0 192.168.1.10:500        192.168.1.13:54240      ESTABLISHED -

If you connect with another client and do netstat again, you will see the following:

    Proto Recv-Q Send-Q Local Address           Foreign Address         State  
    tcp        0      0 0.0.0.0:500             0.0.0.0:*               LISTEN      -
    tcp        0      0 192.168.1.10:500        192.168.1.13:26813      ESTABLISHED -

... that is, the client used another random port for the connection. So there is never confusion between the IP addresses.

Normally, for every connecting client the server forks a child process that communicates with the client (TCP). The parent server hands off to the child process an established socket that communicates back to the client.

When you send the data to a socket from your child server, the TCP stack in the OS creates a packet going back to the client and sets the "from port" to 80.

Multiple clients can connect to the same port (say 80) on the server because on the server side, after creating a socket and binding (setting local IP and port) listen is called on the socket which tells the OS to accept incoming connections.

When a client tries to connect to server on port 80, the accept call is invoked on the server socket. This creates a new socket for the client trying to connect and similarly new sockets will be created for subsequent clients using same port 80.

Words in italics are system calls.

Ref

http://www.scs.stanford.edu/07wi-cs244b/refs/net2.pdf

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • How do multiple clients connect simultaneously to one port, say 80, on a server? [duplicate]
    This question already has answers here: Does the port change when a server accepts a TCP connection? (3 answers) Closed 2 years ago. I understand the basics of how ports work. However, what I don't get is how multiple clients can simultaneously connect to say port 80. I know each client has a unique (for their machine) port. Does the server reply back from an available port to the client, and simply state the reply came from 80? How does this work?
  • Web服务器如何在单个端口(80)上一次处理多个用户的传入请求?(How can a web server handle multiple user's incoming requests at a time on a single port (80)?)
    问题 Web服务器如何在单个端口上同时处理多个传入请求(80)? 示例:同时有300k用户希望从www.abcdef.com看到一个分配了IP 10.10.100.100和端口80的图像。那么,www.abcdef.com如何处理传入用户的负载? 一台服务器(分配了IP 10.10.100.100)可以处理大量的传入用户吗? 如果不是,那么如何将一个IP地址分配给多个服务器来处理此负载? 回答1 来自tcpipguide 使用客户端和服务器套接字对连接的这种识别为我们提供了灵活性,从而允许我们在Internet上理所当然的设备之间实现多个连接。 例如,繁忙的应用程序服务器进程(例如Web服务器)必须能够处理来自多个客户端的连接,否则万维网将几乎无法使用。 由于使用客户端的套接字和服务器的套接字来标识连接,所以这没有问题。 在Web服务器维护上述连接的同时,它可以轻松地具有另一个连接,例如IP地址为219.31.0.44的端口2199。 这由连接标识符表示: (41.199.222.3:80, 219.31.0.44:2199). 实际上,我们可以从同一个客户端到同一个服务器建立多个连接。 每个客户端进程将被分配一个不同的临时端口号,因此,即使它们都尝试访问相同的服务器进程(例如41.199.222.3:80处的Web服务器进程),它们都将具有不同的客户端套接字并代表唯一的连接。
  • 多个客户端如何同时连接到服务器上的一个端口(例如80)? [复制](How do multiple clients connect simultaneously to one port, say 80, on a server? [duplicate])
    问题 这个问题已经在这里有了答案: 服务器接受TCP连接时端口是否会更改? (3个答案) 2年前关闭。 我了解端口如何工作的基础知识。 但是,我没有得到的是多个客户端如何同时连接到端口80。我知道每个客户端都有一个唯一的(对于他们的计算机而言)端口。 服务器是否从可用端口回复给客户端,并仅声明回复来自80? 这是如何运作的? 回答1 首先,“端口”只是一个数字。 一个“与端口的连接”实际上代表的是一个数据包,该数据包的“目标端口”标头字段中指定了该数字。 现在,您的问题有两个答案,一个是有状态协议,一个是无状态协议。 对于无状态协议(即UDP),这是没有问题的,因为“连接”不存在-多个人可以将数据包发送到同一端口,并且他们的数据包将以任何顺序到达。 没有人处于“连接”状态。 对于有状态协议(如TCP),连接由4个元组标识,该元组由源端口和目标端口以及源IP地址和目标IP地址组成。 因此,如果两台不同的计算机连接到第三台计算机上的同一端口,则存在两个不同的连接,因为源IP不同。 如果同一台计算机(或两台位于NAT之后或共享同一IP地址的计算机)两次连接到单个远程端,则按源端口(通常是随机的高编号端口)区分连接。 简而言之,如果我从客户端两次连接到同一Web服务器,那么从我的角度来看,这两个连接将具有与Web服务器不同的源端口和目标端口。 因此
  • 应用程序如何使用端口80 / HTTP而不与浏览器冲突?(how can an application use port 80/HTTP without conflicting with browsers?)
    问题 如果我理解正确,应用程序有时会使用HTTP发送消息,因为使用其他端口可能会导致防火墙问题。 但是,如何在不与Web浏览器之类的其他应用程序冲突的情况下工作呢? 实际上,一次运行的多个浏览器如何不冲突? 他们都监视端口并得到通知吗……您可以通过这种方式共享端口吗? 我觉得这是一个愚蠢的问题,但是我以前从未想到过,在其他情况下,当两个应用程序配置为使用相同的端口时,我会遇到问题。 回答1 有2个端口:源端口(浏览器)和目标端口(服务器)。 浏览器要求操作系统提供可用的源端口(例如,它接收到33123 ),然后与目标端口建立套接字连接(通常为80 / HTTP , 443 / HTTPS )。 当Web服务器收到答案时,它将发送一个响应,该响应的源端口为80,目标端口为33123。 因此,如果您有2个浏览器同时访问stackoverflow.com,则将具有以下内容: Firefox (localhost:33123) <-----------> stackoverflow.com (69.59.196.211:80) Chrome (localhost:33124) <-----------> stackoverflow.com (69.59.196.211:80) 回答2 输出的HTTP请求不会在端口80上发生。当应用程序请求套接字时,它通常会随机接收到一个套接字。 这是源端口
  • WebSocket服务器如何处理多个传入的连接请求?(How WebSocket server handles multiple incoming connection requests?)
    问题 根据这里: HTTP升级标头要求服务器将应用程序层协议从HTTP切换到WebSocket协议。 客户端握手在IE10和服务器之间建立了HTTP-on-TCP连接。 服务器返回其101响应后,应用程序层协议从HTTP切换到WebSockets,该WebSockets使用先前建立的TCP连接。 此时,HTTP完全不可用。 使用轻量级的WebSocket有线协议,现在可以随时通过任一端点发送或接收消息。 因此,我的理解是,第一个客户端与服务器握手后,服务器的80端口将由WebSocket协议垄断。 并且HTTP不再在80端口上工作。 因此,第二个客户端如何与服务器交换握手。 毕竟,WebSocket握手是HTTP格式的。 加1 到目前为止,感谢您提供所有答案。 他们真的很有帮助。 现在,我了解到同一服务器的80端口由多个TCP连接共享。 正如Jan-Philip Gehrcke指出的,这种共享是完全可以的,因为TCP连接由5个元素的元组标识。 我想补充一些想法。 WebSocket和HTTP都只是应用程序级别的协议。 通常,它们都依赖于TCP协议作为其传输。 为什么选择端口80? WebSocket设计有意选择服务器端口80进行握手和后续通信。 从传输级别的角度来看,我认为设计师希望使WebSocket通信看起来像普通的HTTP通信(即服务器端口号仍为80) 。
  • Web服务器可以处理多少个套接字连接?(How many socket connections can a web server handle?)
    问题 假设我要获得共享的,虚拟的或专用的托管,我读到某处服务器/机器一次只能处理64,000个TCP连接的情况,这是真的吗? 不管带宽如何,任何类型的主机可以处理多少个? 我假设HTTP通过TCP起作用。 这是否意味着只有64,000个用户可以连接到该网站,并且如果我想提供更多服务,就不得不迁移到Web场? 回答1 简而言之:您应该能够实现数百万个同时活动的TCP连接并通过扩展HTTP请求来实现。 这告诉您在具有正确配置的正确平台上可以期望的最大性能。 今天,我担心带有ASP.NET的IIS是否会支持100个并发连接(请看我的更新,在较旧的ASP.Net Mono版本上,期望每秒约有1万个响应)。 当我看到这个问题/答案时,我忍不住要回答自己,这里很多问题的答案都是完全错误的。 最好的情况 这个问题的答案必须只涉及最简单的服务器配置,以与可能的下游无数变量和配置脱钩。 因此,请考虑以下情况作为我的答案: 除了保持活动的数据包之外,TCP会话上没有流量(否则,您显然需要相应数量的网络带宽和其他计算机资源) 设计为使用异步套接字和编程的软件,而不是根据池中的每个请求使用硬件线程的软件。 (即带有异步设计的应用程序软件的IIS,Node.js,Nginx ... Web服务器[但不是Apache]) 良好的性能/美元的CPU / Ram。 今天,随便说说具有8GB RAM的i7(4核)。
  • Python SocketServer:发送到多个客户端?(Python SocketServer: sending to multiple clients?)
    问题 好吧,我正在尝试使用SocketServer构建一个小型python prgram,该SocketServer应该将接收到的消息发送给所有连接的客户端。 我被困住了,我不知道如何在服务器端存储客户端,也不知道如何发送到多个客户端。 哦,我的程序每次连接1个以上的客户端时失败,并且每次客户端发送的1条以上消息都失败... 到目前为止,这是我的代码: print str(self.client_address[0])+' connected.' def handle(self): new=1 for client in clients: if client==self.request: new=0 if new==1: clients.append(self.request) for client in clients: data=self.request.recv(1024) client.send(data) class Host: def __init__(self): self.address = ('localhost', 0) self.server = SocketServer.TCPServer(self.address, EchoRequestHandler) ip, port = self.server.server_address self.t =
  • Java 服务器 - 多个端口?(Java Server - Multiple ports?)
    问题 我即将对服务器进行编程,但我想知道我的想法是否可行。 我的程序将输出到多个端口上的多个客户端 - 每个端口可以被多个客户端访问。 通常我会使用线程套接字服务器,但在这种情况下,我需要它为多个端口工作。 我想到的用法是在下面一个模糊的伪代码中: 启动服务器侦听多个端口上的传入连接识别正在连接的端口如果端口 1,则启动一个线程监听客户端并输出消息类型x 如果是端口 2,则启动一个线程监听客户端并输出消息类型y 希望这是有道理的,你可以看到我在做什么。 简单地说:侦听选定的端口,根据正在连接的端口创建线程套接字连接。 这是可行的,还是我最终会使用多线程线程套接字服务器? 编辑:更改措辞以更好地反映问题。 回答1 单个ServerSocket实例不可能侦听多个端口。 您当然可以有多个ServerSocket 。 但是,正如您已经知道的, ServerSocket.accept阻塞。 您可以使用的是ServerSocketChannel 。 它们以类似的方式使用,但不会阻塞。 如果在调用ServerSocketChannel.accept时没有挂起的连接,则它只返回 null。 您可以与Selector一起使用,该Selector接受一组通道并阻塞,直到至少有一个具有挂起的连接。 我不记得如何使用它们的具体细节,但这似乎是一个不错的代码示例。 编辑:这是我自己的例子(伪ish)
  • ServerSocket是否在任意端口上接受返回套接字?(Does ServerSocket accept return socket on arbitrary port?)
    问题 关于Java中的serversockets,我已经看到了许多与此答案相似的答案:“假设您有一台服务器,其serversocket的端口为5000。客户端A和客户端B将连接到我们的服务器。 客户端A在端口5000上向服务器发送请求。客户端A侧的端口由操作系统选择。 通常,操作系统会选择下一个可用的端口。 该搜索的起点是先前使用的端口号+ 1(例如,如果操作系统最近碰到了我们的端口45546,则操作系统将尝试45547)。 假定没有连接问题,服务器将收到客户端A在端口5000上进行连接的请求。然后服务器打开自己的下一个可用端口,并将其发送给客户端。 在这里,客户端A连接到新端口,服务器现在又具有可用的端口5000。” 我已经在关于stackoverflow的多个问题中看到了这样的答案,这些问题涉及如何在accept()的返回套接字中使用与ServerSocket正在侦听的端口不同的端口。 我一直给人的印象是TCP是由四重信息标识的: 客户端IP:客户端端口和服务器IP:服务器端口->协议(以区分TCP和UDP) 那么为什么accept()需要返回绑定到另一个端口的套接字? 在不需要使用服务器计算机上的不同端口进行通信的情况下,在每个报头中发送的信息四方组是否足以区分与同一服务器端口与来自不同计算机的多个连接? 回答1 您在TCP数据包头信息中是正确的。 它包含了: Client
  • 如何在PHP中发出异步GET请求?(How do I make an asynchronous GET request in PHP?)
    问题 我希望对其他服务器上的另一个脚本进行简单的GET请求。 我该怎么做呢? 在一种情况下,我只需要请求一个外部脚本,而无需任何输出。 make_request('http://www.externalsite.com/script1.php?variable=45'); //example usage 在第二种情况下,我需要获取文本输出。 $output = make_request('http://www.externalsite.com/script2.php?variable=45'); echo $output; //string output 老实说,我不想弄混CURL,因为这实际上不是CURL的工作。 我也不想使用http_get,因为我没有PECL扩展名。 fsockopen可以工作吗? 如果是这样,如何在不读取文件内容的情况下执行此操作? 有没有其他办法? 谢谢大家 更新 我应该补充,在第一种情况下,我不想等待脚本返回任何内容。 据我了解,file_get_contents()将等待页面完全加载等? 回答1 file_get_contents会做你想要的 $output = file_get_contents('http://www.example.com/'); echo $output; 编辑:一种触发GET请求并立即返回的方法。 引用自http:/
  • 计网——传输层TCP、UDP协议重点
    目录 传输层基本概念面向连接和无连接端口和套接字多路复用和多路分解 TCP协议TCP报文格式TCP连接控制机制TCP建立连接:三次握手TCP断开连接:四次挥手TCP连接同时打开和同时关闭 TCP流量控制机制滑动窗口机制TCP拥塞控制TCP计时器 UDP协议UDP报文格式 TCP和UDP区别 传输层基本概念   位于OSI协议栈的第四层——传输层,是唯一负责总体数据传输和数据控制的一层,传输层提供端到端的交换数据机制,不仅对上三层提供可靠的传输服务,还对网络层提供可靠的目的地信息。网际层提供的服务是主机间的逻辑通道,通过寻址,将数据包从一个主机发送到另一个主机上,但是如果有多个进程在运行,如何区分发送给哪个进程呢,这也就是传输层所提供的服务。传输层提供服务作用如下: 为网络应用程序提供接口;为端到端连接提供流量控制、差错控制等管理服务;提供多路复用、多路分解机制。 面向连接和无连接   针对不同的实际需求下传输层有两种数据传输协议类型:面向连接和无连接类型,   面向连接: 面向连接就是在通信双方在通信时要先建立一条通信线路,然后进行通信,其过程分为三个阶段,第一阶段是建立链接,第二阶段是连接成功后进行数据传输,第三阶段是数据传输后断开链接。可以联系我们生活中的打电话,当你拨号后服务商回为你分配一条专属链路,在过程中他不会被别人使用,但是当你挂掉电话的时候该链路可重新分配给其他人使用
  • CodeIgniter RESTful,异步/后台进程(CodeIgniter RESTful, async / background process)
    问题 我正在使用codeIgniter RESTful API(https://github.com/philsturgeon/codeigniter-restserver),该API将信息(json格式)返回到我的android / iphone应用。 有一个操作,我发送一些值,如果一切正常,我返回200代码作为响应。 现在,我想以相同的方法添加一个新操作:使用APNS(Apple Push Notificacion Service)和GCM(Google Cloud Messaging)发送有关此修改的通知。 当我必须发送不超过3-5条通知时,它工作得很好,问题出在APNS上,因为我必须一次一条地发送此消息,并且需要很长时间,所以我的应用程序会收到超时异常(所有通知都是发送,但用户得到错误连接...) 我可以发送200码响应,然后继续发送此通知吗? (这样的事情...) function my_update_method_post(){ //....GET my POST values update($data); $this->response(array('result'=>1),200)); //Send Notifications .... } 提前致谢... 回答1 我找到了一个最适合我的解决方案,因为我不期望任何结果值。 如果无法发送通知...我将其记录在数据库中。
  • 如何使用 PHP 捕获完整的 HTTP 请求数据(标头和正文)?(How to capture full HTTP request data (headers and body) with PHP?)
    问题 我在实现适用于 Java 的 API 时遇到问题,但无法使用 cURL。 到目前为止,我们已经完成了所有工作,Java 发出的请求与我们发出的请求之间肯定存在一些不同之处。 在 PHP 中,我们可以通过查看$_SERVER['HTTP_*']变量来获取头数据,我们可以从file_get_contents('php://input');获取请求正文file_get_contents('php://input'); 但是我们无法获得从用户代理发送到客户端的确切数据。 是否可以使用 PHP 获取用户代理发送的完整请求? 包括标题和正文? 如果是,那又如何? 我找到的唯一示例是here,但此示例以我提到的方式获取正文,而它通过解析$_SERVER获取标头,这似乎是一种黑客攻击,因为它从来不是实际发送的 100%。 感谢所有帮助和提示! 回答1 对于标题,您可以尝试 apache_request_headers(),对于正文,除了file_get_contents('php://input');我不知道其他方法file_get_contents('php://input'); 回答2 老问题,但对于将来需要这样做的任何人......最好(可能唯一)的方法是通过成为服务器来完全控制服务器。 设置一个套接字服务器侦听端口 80(如果这是您需要服务器执行的全部操作),或任何其他端口(如果
  • 运维开发岗春招面经
    作者:许愿offer1007 链接:https://www.nowcoder.com/discuss/394222 来源:牛客网 陆续更新了一些题目的答案或笔记 可能看起来有点乱 还是希望对大家有帮助哈~ —————————————————————————————————————————————— 腾讯云计算转后台开发一面(电话面): 1、docker怎么使用,容器怎么理解,k8s(简历里写了,但是最早面的,准备的不好) 2、数组和列表的区别 3、tcp time-wait发生在哪个阶段(第四次挥手结束后,等待确认服务器收到客户端发出的ACK报文) 【time-wait客户端主动关闭等待,close-wait服务器被动关闭等待】 4、Linux 查询某个时间点以来的文件?(find -ctime) 5、mysql的了解程度 6、深浅拷贝 加上自我介绍和项目介绍一共20分钟,凉的透 腾讯IEG业务运维一面(视频面): 1、awk指令,-F分隔符 0 整行0整行NF 最后一列 2、运维工具了解么(我说了ansible) 3、docker原理、k8s原理 4、ceph原理,几种存储:块存储、对象存储、文件存储 5、flask有哪些库 6、CI/CD 【CI:编译、测试、输出结果,核心在于新增代码能够与原先代码正确的集成 CD:交付,核心在于可交付的产物,在生产环境可用 CD:部署,自动化
  • 使用集群将Socket.IO扩展到多个Node.js进程(Scaling Socket.IO to multiple Node.js processes using cluster)
    问题 用这个来扯掉我的头发。。。有人能将Socket.IO扩展到Node.js的集群模块产生的多个“工作”进程吗? 可以说我在四个工作进程(伪)上具有以下内容: // on the server var express = require('express'); var server = express(); var socket = require('socket.io'); var io = socket.listen(server); // socket.io io.set('store', new socket.RedisStore); // set-up connections... io.sockets.on('connection', function(socket) { socket.on('join', function(rooms) { rooms.forEach(function(room) { socket.join(room); }); }); socket.on('leave', function(rooms) { rooms.forEach(function(room) { socket.leave(room); }); }); }); // Emit a message every second function send() { io
  • ISA Server 2006使用基础知识
    Internet Security and Acceleration(简称ISA)Server是Microsoft推出的集防火墙、代理服务器于一身的服务器端软件,它同时有代理服务器(代理客户端共享上网)、防火墙(安全连接Internet、安全发布网络内各项服务如Web、FTP、E-mail到Internet上、提供安全的×××连接)功能。ISA Server的代理服务器中的“缓存”功能是业界最好、速度最快的,许多大型公司都使用ISA Server中的代理服务器功能作为缓存服务器。11.1 ISA Server功能概述 Microsoft Internet Security and Acceleration (ISA) Server 2006是可扩展的企业防火墙和Web缓存服务器,它构建在Microsoft Windows Server 2003和Windows 2000 Server操作系统安全、管理和目录上,以实现基于策略的访问控制、加速和网际管理。 当企业网络接入Internet时,Internet为组织提供与客户、合作伙伴和员工连接的机会。这种机会的存在,同时也带来了与安全、性能和可管理性等有关的风险和问题。ISA Server旨在满足当前通过Internet开展业务的公司的需要。ISA Server提供了多层企业防火墙,来帮助防止网络资源受到病毒、***的**
  • Nginx(三)------nginx 反向代理
    Nginx(三)------nginx 反向代理  Nginx 服务器的反向代理服务是其最常用的重要功能,由反向代理服务也可以衍生出很多与此相关的 Nginx 服务器重要功能,比如后面会介绍的负载均衡。本篇博客我们会先介绍 Nginx 的反向代理,当然在了解反向代理之前,我们需要先知道什么是代理以及什么是正向代理。1、代理  在Java设计模式中,代理模式是这样定义的:给某个对象提供一个代理对象,并由代理对象控制原对象的引用。  可能大家不太明白这句话,在举一个现实生活中的例子:比如我们要买一间二手房,虽然我们可以自己去找房源,但是这太花费时间精力了,而且房屋质量检测以及房屋过户等一系列手续也都得我们去办,再说现在这个社会,等我们找到房源,说不定房子都已经涨价了,那么怎么办呢?最简单快捷的方法就是找二手房中介公司(为什么?别人那里房源多啊),于是我们就委托中介公司来给我找合适的房子,以及后续的质量检测过户等操作,我们只需要选好自己想要的房子,然后交钱就行了。  代理简单来说,就是如果我们想做什么,但又不想直接去做,那么这时候就找另外一个人帮我们去做。那么这个例子里面的中介公司就是给我们做代理服务的,我们委托中介公司帮我们找房子。  Nginx 主要能够代理如下几种协议,其中用到的最多的就是做Http代理服务器。  2、正向代理  弄清楚什么是代理了,那么什么又是正向代理呢?
  • Ab负载测试(ab load testing)
    问题 有人可以指导我使用apache Bench工具( ab )进行网站负载测试的过程吗? 我想知道以下内容: 该网站每分钟可以处理多少人? 请引导我完成应该解决的命令。 我尝试了所有教程,但它们令人困惑。 回答1 apache基准测试工具非常基础,虽然可以为您提供一些性能方面的扎实思路,但是如果您打算让站点承受严重的生产压力,则仅依靠它是一个坏主意。 话虽如此,这是最常见和最简单的参数: -c :(“并发性”)。 指示将同时访问该站点的客户(人员/用户)数量。 当ab运行时,将有-c客户访问该站点。 这实际上决定了您的网站在基准测试期间所承受的压力。 -n :指示要发出多少个请求。 这只是决定基准的长度。 服务器可以支持的高-n值和-c值是确保事情在持续压力下不会破裂的好主意:5秒钟支持压力与5个小时支持压力是不同的。 -k :这实际上是“ KeepAlive”功能浏览器的功能。 您不需要为-k传递值,因为它是“布尔值”(意味着:它表示您希望测试使用HTTP中的Keep Alive标头并维持连接)。 由于浏览器会执行此操作,因此您可能希望模拟浏览器对网站的压力和流量,因此建议您对此进行基准测试。 最后一个论点仅仅是主持人。 默认情况下,如果未指定,它将按http://协议。 ab -k -c 350 -n 20000 example.com/ 通过发出上面的命令
  • How WebSocket server handles multiple incoming connection requests?
    According to here: The HTTP Upgrade header requests that the server switch the application-layer protocol from HTTP to the WebSocket protocol. The client handshake established a HTTP-on-TCP connection between IE10 and server. After the server returns its 101 response, the application-layer protocol switches from HTTP to WebSockets which uses the previously established TCP connection. HTTP is completely out of the picture at this point. Using the lightweight WebSocket wire protocol, messages can now be sent or received by either endpoint at any time. So, my understanding is, after the 1st
  • 为什么node.js一次只能处理六个请求?(Why is node.js only processing six requests at a time?)
    问题 我们有一个node.js服务器,该服务器将REST API实施为中央服务器的代理,而中央服务器具有一个稍有不同且不对称的REST API。 我们的客户端运行在各种浏览器中,它要求节点服务器从中央服务器获取任务。 节点服务器从中央服务器获取所有任务ID的列表,并将其返回给客户端。 然后,客户端通过代理对每个ID进行两次REST API调用。 据我所知,这些工作都是异步完成的。 在控制台日志中,启动客户端时,它看起来像这样: Requested GET URL under /api/v1/tasks/*: /api/v1/tasks/ 从中央服务器获取列表需要花费几秒钟的时间。 一旦收到响应,服务器就会很快将其拒绝: Requested GET URL under /api/v1/tasks/id/:id :/api/v1/tasks/id/438 Requested GET URL under /api/v1/workflow/id/:id :/api/v1/workflow/id/438 Requested GET URL under /api/v1/tasks/id/:id :/api/v1/tasks/id/439 Requested GET URL under /api/v1/workflow/id/:id :/api/v1/workflow/id/439