AI 助理
文档备案控制台
开发者社区 开发与运维 文章 正文

《bug记录》在利用TCP协议创建【服务器-客户端交互程序】中出现的一些问题

2023-04-25 160
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 《bug记录》在利用TCP协议创建【服务器-客户端交互程序】中出现的一些问题

一、bug描述

88d1152fd0624da0b203a23eed474eb9.png今天在写上传交互程序中，当我把服务器和客户端成功启动后，在客户端输入请求指令的时候，出现了上述情况。

下面是服务器的代码

package network;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
        Socket clientSocket = serverSocket.accept();
        processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    }
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

客户端的代码：

package network;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoClient {
    Socket socket = null;
    public TcpEchoClient() throws IOException {
        // 指定客户端要连接的服务器
        socket = new Socket("127.0.0.1", 8000);
        // 程序走到了这里，说明客户端和服务器就已经成功建立了连接
    }
    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("当前是客户端，请输入请求");
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) { // InputStream用于读取， OutputStream用于发送
            // 对我们的读取和发送进行写包装，使得读取和包装更方便
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
            while (true) {
                System.out.print("> ");
                // 1、客户端从键盘输入请求
                String request = scanner.nextLine();
                // 在这里我们虽然在输入内容后用换行符来进行了结束，但我们用于接收的request并没有读取的换行符——它被nextLine()给吞吃了
                // 2、把请求发送给服务器
                printWriter.write(request);
                // 这么写会产生一个bug, 要printWriter.println()会自动给我们要写入的添加一个换行符
                // 可以让服务器在读取请求时遇到换行就结束，不至于陷入阻塞
                printWriter.flush(); // 刷新缓冲区
                // 3、从服务器读取响应内容
                String response = scannerNet.nextLine();
                // 4、打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            socket.close();
        }
}
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient();
        client.start();
    }
}

二、问题分析

于是我打开java的工具包jconsole.exe查看相关的线程执行情况


087bf5640df9418ea8dfa41f2a03ddf0.png

7d31728b3c2b45c4a81e0ea8e6edcb42.png

客户端相关代码：


994905ed32d642f7863b7019c84bd1e7.png

那么客户端在这里出现异常正常吗？很正常因为我们的服务器在正常情况下，当把响应发送给客户端后，是要打印日志的。但从我们上述的运行结果来看，我们的服务器并没有打印响应（这说明服务器没有成功的把响应发送给客户端，而是陷入了阻塞）


所以客户端在这里的阻塞是正常的


对应的服务器代码：

b937fdf141ab4e18ab69619698338c29.png

那么我们在来看看服务器的代码究竟在哪里出现了问题：’


77eddf6f7a1d4837958d39087962b8d9.png

对应的服务器代码：

e40482a5c38f4c0087959dbee6213565.png


为什么会在scannerNet.nextLine()这里陷入阻塞呢？nextLine不是遇到回车就结束吗？我们在客户端输入请求后明明敲了一个回车呀！

 

通过下面这个栗子我们可以发现一些问题：


ee3895bff2ec41d9b016df59df97c2f1.png

 

那么如果这样的话， 我们服务器从客户端读取request的时候，接收到的数据也是没有换行符的——也就是说：

String request = scannerNet.nextLine();

这一行的读取一直无法正常的结束，线程自然就陷入了阻塞当中。


三、问题解决

清楚了这一点就好办了，我们在下面的客户端代码中：


8723afa8abb246d5b16c11abadb72ea1.png

对应的服务器代码：

01ae52bd920f45049a0c25fe59409335.png

🍑改过后的服务器代码

package network;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket。
        Socket clientSocket = serverSocket.accept();
        processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
    }
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.println(response);
                // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

🍑改过后的客户端代码：

package network;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoClient {
    Socket socket = null;
    public TcpEchoClient() throws IOException {
        // 指定客户端要连接的服务器
        socket = new Socket("127.0.0.1", 8000);
        // 程序走到了这里，说明客户端和服务器就已经成功建立了连接
    }
    public void start() throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("当前是客户端，请输入请求");
        try (InputStream inputStream = socket.getInputStream();
             OutputStream outputStream = socket.getOutputStream()) { // InputStream用于读取， OutputStream用于发送
            // 对我们的读取和发送进行写包装，使得读取和包装更方便
            Scanner scannerNet = new Scanner(inputStream);
            PrintWriter printWriter = new PrintWriter(outputStream);
            // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
            while (true) {
                System.out.print("> ");
                // 1、客户端从键盘输入请求
                String request = scanner.nextLine();
                // 在这里我们虽然在输入内容后用换行符来进行了结束，但我们用于接收的request并没有读取的换行符——它被nextLine()给吞吃了
                // 2、把请求发送给服务器
                printWriter.println(request);
                // printWriter.write(request);
                // 这么写会产生一个bug, 要printWriter.println()会自动给我们要写入的添加一个换行符
                // 可以让服务器在读取请求时遇到换行就结束，不至于陷入阻塞
                printWriter.flush(); // 刷新缓冲区
                // 3、从服务器读取响应内容
                String response = scannerNet.nextLine();
                // 4、打印日志
                System.out.printf("request: %s, response: %s\n", request, response);
            }
        }
        finally {
            socket.close();
        }
}
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient();
        client.start();
    }
}

测试案例

29fe6eca115b48d4987f83e64dd018c0.png

四、进一步的改进

实现多线程服务器

package network;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        while (true) {
            // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket
            // 如果当前没有客户端来建立连接, 就会阻塞等待!!
            Socket clientSocket = serverSocket.accept();
            // processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
            // [版本2] 多线程版本. 主线程负责拉客, 新线程负责通信
            // 虽然比版本1 有提升了, 但是涉及到频繁创建销毁线程, 在高并发的情况下, 负担比较重的.
            Thread thread = new Thread(() -> {
                try {
                    processConnection(clientSocket);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            });
            thread.start();
        }
    }
    // 通过这个方法, 给当前连上的这个客户端, 提供服务!!
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 falseSystem.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.println(response);
                // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("[%s:%d]  request: %s, response: %s\n",
                        clientSocket.getInetAddress(), clientSocket.getPort(),
                        request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}

668fe80a45fc480095bca50546adb09e.png

通过线程池实现多线程服务器

package network;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TcpEchoServer {
    ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        ExecutorService service = Executors.newCachedThreadPool();// 此处不太适合使用 "固定个数的"
        while (true) {
            // 服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端Socket
            // 如果当前没有客户端来建立连接, 就会阻塞等待!!
            Socket clientSocket = serverSocket.accept();
            // processConnection(clientSocket); // 单线程模式——即该服务器无法同时为多个客户端同时提供服务
            // [版本2] 多线程版本. 主线程负责拉客, 新线程负责通信
            // 虽然比版本1 有提升了, 但是涉及到频繁创建销毁线程, 在高并发的情况下, 负担比较重的.
//            Thread thread = new Thread(() -> {
//                try {
//                    processConnection(clientSocket);
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            });
//            thread.start();
            // [版本3] 使用线程池, 来解决频繁创建销毁线程的问题.
            // 此处不太适合使用 "固定个数的"
            service.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        processConnection(clientSocket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
    // 通过这个方法, 给当前连上的这个客户端, 提供服务!!
    // 这里我们建立长连接——一次连接中，会有 N次请求，N次响应
    public void processConnection(Socket clientSocket) throws IOException {
        System.out.printf("连接成功！[%s:%d]\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
        try (InputStream inputStream = clientSocket.getInputStream();
             OutputStream outputStream = clientSocket.getOutputStream() ) {
            Scanner scannerNet = new Scanner(inputStream); // 对我们的读取进行嵌套
            PrintWriter printWriter = new PrintWriter(outputStream);
            while (true) {
                if (!scannerNet.hasNext()) {
                    // 说明此时连接中断，服务器无法继续从客户端读取到请求
                    // 连接断开. 当客户端断开连接的时候, 此时 hasNext 就会返回 false
                    System.out.printf("[%s:%d] 断开连接!\n", clientSocket.getInetAddress().toString(), clientSocket.getPort());
                    break;
                }
                // 1、读取客户端的请求
                String request = scannerNet.nextLine();
                // 从客户端读取到的请求，如果客户端在输入请求的时候，只是通过nextLine敲了回车，然后就通过printWrite.write发送给我们的服务器，
                // 这时服务器接收到的数据是不带换行符的，换行符在我们的客户端nextLine输入的过程中就已经被吞吃了，所有为了避免String request = scanner.nextLine();无法正常读取（nextLine只有遇到换行才结束)
                // 所以在我们的客户端在发送时要通过PrintWrite.println()来发送，会给我们自动添加一个换行符
                // 2、处理客户端发来的请求
                String response = process(request);
                // 3、把响应发送给客户端
                printWriter.println(response);
                // printWriter.write(response); // 这样写有bug，因为我们当前的response中没有带换行符，
                printWriter.flush(); // 刷新缓冲区
                // 打印日志
                System.out.printf("[%s:%d]  request: %s, response: %s\n",
                        clientSocket.getInetAddress(), clientSocket.getPort(),
                        request, response);
            }
        }
        finally {
            clientSocket.close(); // 每一次建立连接都会创建一个clientSocket，该连接结束后要及时关闭，避免内存泄漏
        }
    }
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(8000);
        server.start();
    }
}


文章标签：
日志服务
Java
网络协议
关键词：
云服务器 ECS程序
协议云服务器 ECS
云服务器 ECS bug
tcp云服务器 ECS
云服务器 ECS交互
相关实践学习
通过日志服务实现云资源OSS的安全审计
本实验介绍如何通过日志服务实现云资源OSS的安全审计。
是小鱼儿哈
目录
相关文章
蓝易云
|
9月前
|
存储 数据库 Python
使用HTTP POST协议将本地压缩数据发送到服务器
总的来说，使用HTTP POST协议将本地压缩数据发送到服务器是一个涉及多个步骤的过程，包括创建压缩文件，设置HTTP客户端，发送POST请求，以及服务器端的处理。虽然这个过程可能看起来复杂，但一旦你理解了每个步骤，就会变得相对简单。
蓝易云
339 19
蓝易云
|
10月前
|
安全 网络安全 定位技术
网络通讯技术：HTTP POST协议用于发送本地压缩数据到服务器的方案。
总的来说，无论你是一名网络开发者，还是普通的IT工作人员，理解并掌握POST方法的运用是非常有价值的。它就像一艘快速，稳定，安全的大船，始终为我们在网络海洋中的冒险提供了可靠的支持。
蓝易云
301 22
陈明勇
|
10月前
|
人工智能 搜索推荐 程序员
用 Go 语言轻松构建 MCP 客户端与服务器
本文介绍了如何使用 mcp-go 构建一个完整的 MCP 应用，包括服务端和客户端两部分。 - 服务端支持注册工具（Tool）、资源（Resource）和提示词（Prompt），并可通过 stdio 或 sse 模式对外提供服务； - 客户端通过 stdio 连接服务器，支持初始化、列出服务内容、调用远程工具等操作。
陈明勇
2330 5
Echo_Wish
|
11月前
|
机器学习/深度学习 人工智能 运维
机器学习+自动化运维：让服务器自己修Bug，运维变轻松！
机器学习+自动化运维：让服务器自己修Bug，运维变轻松！
Echo_Wish
468 14
aliyun7406565512-10053
|
存储 开发工具 git
[Git] 深入理解 Git 的客户端与服务器角色
Git 的核心设计理念是分布式，每个仓库既可以是客户端也可以是服务器。通过 GitHub 远程仓库和本地仓库的协作，Git 实现了高效的版本管理和代码协作。GitHub 作为远程裸仓库，存储项目的完整版本历史并支持多客户端协作；本地仓库则通过 `.git` 文件夹独立管理版本历史，可在离线状态下进行提交、回滚等操作，并通过 `git pull` 和 `git push` 与远程仓库同步。这种分布式特性使得 Git 在代码协作中具备强大的灵活性和可靠性。
aliyun7406565512-10053
373 18
[Git] 深入理解 Git 的客户端与服务器角色
蓝易云
|
11月前
|
网络协议 开发者 Python
Socket如何实现客户端和服务器间的通信
通过上述示例，展示了如何使用Python的Socket模块实现基本的客户端和服务器间的通信。Socket提供了一种简单且强大的方式来建立和管理网络连接，适用于各种网络编程应用。理解和掌握Socket编程，可以帮助开发者构建高效、稳定的网络应用程序。
蓝易云
600 10
程序员在线
|
4月前
|
弹性计算 运维 安全
阿里云轻量应用服务器与云服务器ECS啥区别？新手帮助教程
阿里云轻量应用服务器适合个人开发者搭建博客、测试环境等低流量场景，操作简单、成本低；ECS适用于企业级高负载业务，功能强大、灵活可扩展。二者在性能、网络、镜像及运维管理上差异显著，用户应根据实际需求选择。
程序员在线
389 10
翼龙云TG_yilongcloud
|
4月前
|
运维 安全 Ubuntu
阿里云渠道商：服务器操作系统怎么选？
阿里云提供丰富操作系统镜像，涵盖Windows与主流Linux发行版。选型需综合技术兼容性、运维成本、安全稳定等因素。推荐Alibaba Cloud Linux、Ubuntu等用于Web与容器场景，Windows Server支撑.NET应用。建议优先选用LTS版本并进行测试验证，通过标准化镜像管理提升部署效率与一致性。
翼龙云TG_yilongcloud
540 4
程序员在线
|
4月前
|
弹性计算 ice
阿里云4核8g服务器多少钱一年？1个月和1小时价格，省钱购买方法分享
阿里云4核8G服务器价格因实例类型而异，经济型e实例约159元/月，计算型c9i约371元/月，按小时计费最低0.45元。实际购买享折扣，1年最高可省至1578元，附主流ECS实例及CPU型号参考。
程序员在线
567 8
翼龙云TG_yilongcloud
|
4月前
|
存储 监控 安全
阿里云渠道商：云服务器价格有什么变动？
阿里云带宽与存储费用呈基础资源降价、增值服务差异化趋势。企业应结合业务特点，通过阶梯计价、智能分层、弹性带宽等策略优化成本，借助云监控与预算预警机制，实现高效、可控的云资源管理。
翼龙云TG_yilongcloud
201 2

热门文章

最新文章

  • 1
    阿里云服务器搭建WordPress网站完整步骤图文教程（附二级域名解析）
  • 2
    java开发之使用websocket实现web客户端与服务器之间的实时通讯
  • 3
    QPS 提升60%，揭秘阿里巴巴轻量级开源 Web 服务器 Tengine 负载均衡算法
  • 4
    阿里云ECS Ubuntu 实例开放防火墙端口仍无法访问问题解决（安全组规则应用）
  • 5
    什么是无影云桌面？与ECS云服务器有什么区别?
  • 6
    在国内所有云服务器中，最稳定的就属阿里云服务器了，今天我们具体阿里云服务器可以干嘛？八大用途你都知道吗？
  • 7
    阿里云服务器2核4G配置不同实例最新收费标准价格与选择参考
  • 8
    阿里云服务器如何选择CPU、内存、宽带和系统盘等等
  • 9
    阿里云怎么购买云速成美站: 建站模板+云服务器
  • 10
    服务器建设选择了阿里云
  • 1
    阿里云服务器多少钱一年？亲自整理ECS、轻量和GPU服务器租赁价格表
    1420
  • 2
    阿里云轻量应用服务器实例：通用型、多公网IP型、CPU优化、国际及容量型区别对比
    870
  • 3
    阿里云服务器2核4G/4核8G/8核16G配置价格、可选实例区别与选型指南参考
    1334
  • 4
    阿里云渠道商：服务器操作系统怎么选？
    540
  • 5
    阿里云轻量应用服务器38元1年和云服务器99元1年怎么选？二者性能区别及选择参考
    533
  • 6
    硅谷GPU单节点服务器：技术解析与应用全景
    281
  • 7
    阿里云渠道商：云服务器价格有什么变动？
    201
  • 8
    阿里云渠道商：如何挑选阿里云服务器配置？
    205
  • 9
    阿里云服务器五代至九代实例规格详解及性能提升对比，场景适配与选择指南参考
    440
  • 10
    租用阿里云服务器一年要多少钱？ECS、轻量和GPU服务器租赁价格，手动整理
    992

    • 相关课程

    更多
  • ECS上云入门三部曲
  • 服务器硬件基础
  • Linux Web服务器Nginx搭建与配置
  • 7天玩转云服务器
  • 云服务器选型、迁云最佳实践
  • 云服务器ECS基本操作

    • 相关电子书

    更多
  • 如何运维千台以上游戏云服务器
  • 网站/服务器取证 实践与挑战
  • ECS快储存加密技术
    • 下一篇
    第五届伏魔挑战赛如约来袭，诚邀各路高手来战！