Huawei Cloud Bulk Top-up Discounts Huawei Cloud ECS beginner tutorial

So you’ve decided to try Huawei Cloud’s Elastic Cloud Server (ECS). Congratulations: you are now the proud operator of a digital machine that lives in a data center and behaves like a pet—only it won’t purr, it will just run commands and occasionally ignore you if you forget a firewall rule. This tutorial is built for absolute beginners. No mysticism, no “just click this one button you can’t see,” and no assuming you already know what a security group is. We’ll take it step by step, explain the why, and give you enough practical guidance to get your first ECS instance running smoothly.

What is Huawei Cloud ECS?

Huawei Cloud ECS (Elastic Cloud Server) is essentially a virtual computer you can spin up on demand. Think of it as renting a computer from the cloud: you choose the CPU, memory, operating system, storage, and network settings. You then connect to it over the network, install software, host a website, run an application, or practice sysadmin skills. The “elastic” part means you can resize and manage resources more flexibly than with traditional hosting.

If you’re coming from home computing, imagine you’re setting up a mini desktop in the sky. The keyboard and monitor aren’t physically attached to your desk, but the operating system is real, the processes are real, and you can administer it like any other server. Your big difference is that you can create or replace it without visiting a store, and you can scale it without moving furniture (unless you count the furniture you used to feel like you needed a second monitor to figure everything out).

Before you start: prerequisites and mindset

Before you build your first ECS instance, you’ll want a few things lined up. The goal is to avoid the classic beginner experience of clicking around until you accidentally create an expensive instance named “final-final-v3,” then panic because you don’t know how to stop it.

1) Have a Huawei Cloud account

You’ll need a Huawei Cloud account. In many tutorials, this step gets skipped, but you can’t create ECS without being logged in somewhere. If you already have an account, great. If not, get that part done first.

2) Be ready for region selection

Cloud providers organize resources by region (like “US-West” or “Asia-Singapore,” depending on availability). Your choice affects latency, compliance, and sometimes service availability. For a beginner, a good default is: pick the region closest to where your users or your own network are located. If you’re just learning, any region you can access will work.

Huawei Cloud Bulk Top-up Discounts 3) Understand you’re configuring security, not just a server

When you create an ECS instance, you’re not only selecting a machine size. You’re also defining rules about who can reach your server. This is where the “mysteriously wrong” moments often happen. We’ll cover security group basics in a clear way later.

Huawei Cloud Bulk Top-up Discounts The big picture: what you’ll configure when creating an ECS instance

When you click “create ECS instance,” you’ll typically see settings like these:

• Region and availability zone
• Huawei Cloud Bulk Top-up Discounts Image (operating system template)
• Instance flavor (CPU and memory)
• Network configuration (virtual private cloud, subnet)
• Security group rules (firewall-like settings)
• Storage configuration (system disk size and type)
• Authentication (SSH key pair, password, etc.)

Different Huawei Cloud interfaces can present options slightly differently, but the concepts are the same. Your job is to choose sensible beginner defaults, then learn what each choice means.

Step-by-step: create your first ECS instance

Let’s walk through a typical beginner flow. Your button names may vary slightly, but the steps below map to the usual ECS setup.

Step 1: Log in and open ECS

Log in to Huawei Cloud Console, then locate the ECS service. If you see a search bar for services, type “ECS” and click the appropriate result. You’ll usually land on a dashboard showing your existing instances (if any) and options to create new ones.

Step 2: Click “Create ECS instance”

Look for a button like “Create Instance” or “Buy/Buy Elastic Cloud Server.” Click it. From here, you’ll configure instance settings.

Step 3: Choose region and availability zone

Select a region. For learning, choose the default region that’s already selected or the one closest to you. Availability zones are typically subdivisions within a region. Beginners can often leave the default unless you have a specific reason to choose another zone.

Why this matters: if your users are near a region, they’ll experience lower latency. If you pick a region far away, everything still works, but it may feel like your server is running through a slow-motion time machine.

Step 4: Pick an operating system image

ECS requires an “image,” which usually means an operating system template such as Ubuntu, CentOS, Debian, or a Huawei Cloud-provided image. Choose one familiar to you.

If you’re unsure, Ubuntu is a popular beginner choice because it’s friendly and widely supported. If you already know Linux basics, stick with what you know. If you’re learning from scratch, pick a common distro so you can find help easily when you search for error messages.

Step 5: Select the instance flavor (CPU and memory)

This is where you decide how powerful your server should be. For beginners, you don’t need a monster machine. A small instance is perfect for learning, running a simple web server, or practicing deployments.

Typical beginner selection:

• Few vCPUs (like 1–2)
• Small to moderate memory (like 2–4 GB)

If you choose too small, you’ll still learn—but your website might feel sluggish when you test with a lot of traffic. If you choose too big, you’ll pay more than necessary while you learn basic commands. Cloud learning is about steady progress, not showing off.

Step 6: Configure networking (VPC and subnet)

ECS instances live inside a VPC (Virtual Private Cloud) and subnet. For beginners, you might see options like:

• Create a new VPC or use an existing one
• Select a subnet within that VPC

If you don’t have a VPC yet, the wizard may offer to create one automatically. That’s usually fine for a beginner. If you’re in a learning environment, default VPC settings are often acceptable.

The important thing to understand is: your ECS instance needs a network in which it can communicate. The VPC/subnet choices determine IP address ranges and how traffic flows.

Step 7: Choose authentication method (SSH key recommended)

Most Linux ECS setups use SSH key pairs for authentication. Password-based login may also be available depending on the image and security policy, but SSH keys are commonly recommended because they’re more secure and easier to manage properly.

If the interface asks for a key pair, you’ll usually:

• Select an existing key pair, or
• Create a new key pair and download the private key

Important beginner tip: once you download the private key, save it somewhere safe. Do not “download then forget.” Your server expects that key. If you lose it, you may have to recreate the instance or use recovery options, which is not the fun kind of learning.

Step 8: Configure system disk (storage)

You’ll be asked for system disk size and sometimes disk type. For beginners, a moderate system disk size is enough. If you plan to install extra packages, run a database, or store lots of logs, you’ll eventually want more space.

A good initial value for learning is often something like 20–40 GB, depending on the options you see. If you later realize you need more storage, many setups allow disk expansion without panic-level recreation.

Step 9: Network access: public IP and security group

This is the part that can cause your first “why can’t I connect?” moment.

In many ECS configurations, you choose whether your instance gets a public IP. If you want to access it from your laptop/desktop over the internet, you typically need:

• A public IP (or an associated floating/public address)
• A security group rule allowing inbound traffic (like SSH on port 22)

You may see options such as:

• Assign public IP: yes/no
• Security group: select existing or create new

For a beginner who wants to SSH in, you’ll typically ensure inbound rule for SSH exists. That means allowing TCP port 22 from your IP address (best practice) or from a broader range (less secure but sometimes used for learning).

Best practice: allow only your current public IP (or your company office IP range). This prevents random internet traffic from hitting your server. For learning at home, you can usually restrict to your own IP.

If you get the security group wrong, your SSH client will attempt to connect and then hang or fail. It won’t say “security group misconfigured.” It will just act like it’s shy.

Step 10: Review settings and create

Before you click create, do a quick sanity check:

• Region is correct
• OS image looks right
• Instance size is reasonable
• SSH authentication is set (key or password)
• Public IP and security rules are configured

Then click create. The instance will take a few minutes to be ready. You may see a provisioning status like “creating,” “initializing,” or “running.” Wait until it shows healthy or running.

Connecting to your ECS instance

Once your instance is running, you’ll need its IP address. In many cases, you’ll see an “EIP” (Elastic IP) or “public IP” field in the instance details. Use that address for SSH.

Connecting with SSH (Linux/macOS)

Open a terminal on your computer. Make sure your private key file has the correct permissions. A common fix on macOS/Linux is:

chmod 600 /path/to/your-key.pem

Then SSH in:

ssh -i /path/to/your-key.pem your-user@your-server-ip

The “your-user” depends on the OS image. Common defaults are:

• Ubuntu: ubuntu
• CentOS/Oracle Linux often: ec2-user (varies)
• Debian: debian

If you’re not sure, check the image documentation or the instance creation details. The console often provides recommended login usernames.

Connecting with SSH (Windows)

Windows now has built-in SSH in modern versions, and many users also rely on tools like PuTTY or PowerShell. If using PowerShell:

ssh -i C:\path\to\your-key.pem your-user@your-server-ip

If your key is in PEM format and SSH complains, you might need to convert it depending on the tool. For PuTTY, you typically convert the key to PPK. If you run into issues, check the error message carefully. Most are solvable with the right key format and permissions.

If SSH fails: the beginner troubleshooting checklist

Here’s the “don’t panic, verify things” list. Many connection problems fall into predictable categories:

• Wrong IP: Are you using the public IP, not the private one? Public access needs the public address.
• Security group blocks port 22: Make sure inbound rule allows TCP 22 from your IP.
• Wrong username: SSH user differs per OS image.
• Key mismatch: Your private key must correspond to the key pair used during instance creation.
• Instance not ready: If you connect too early, it may not accept connections yet.
• Network/NAT issues: Some configurations require a specific setup for outbound or public routing.

If you want a quick test: from your computer, check whether you can reach the server’s port 22 using a networking tool. Some OSes have built-in ways, but even without that, the security group and IP choice are usually the biggest culprits.

First-run basics inside your ECS

Once you’re in via SSH, your mission is to make your server feel less like a random machine and more like a useful one. Here are beginner-friendly first-run tasks.

Update packages

On a Linux server, start by updating your package lists and upgrading installed packages. For Ubuntu:

sudo apt update && sudo apt upgrade -y

Huawei Cloud Bulk Top-up Discounts For CentOS/RHEL-like distributions:

sudo yum update -y

Why do this? Because base images can be slightly behind, and updates fix bugs and security issues. Also, it helps you verify that you have working internet access from the server.

Create a non-root user (optional but recommended)

Many beginners log in as the default user and then run commands with sudo. That’s fine. If you prefer a dedicated workflow, you can create a new user and configure sudo access. It’s not strictly required for learning, but it’s a good habit.

Check system information

Use basic commands to confirm your instance resources:

• CPU and load:

  uptime

• Memory:

  free -h

• Disk usage:

  df -h

• Processes:

  top

  or

  htop

This gives you confidence you’re not building a spaceship with duct tape. It’s also how you spot issues early.

Install common tools

Common beginner utilities might include:

• curl (for downloading or testing)
• wget (for file retrieval)
• git (for cloning repositories)
• htop (for nicer process viewing)

For Ubuntu, for example:

sudo apt install -y curl wget git htop

Huawei Cloud Bulk Top-up Discounts Installing tools isn’t mandatory, but it makes learning faster and less annoying.

Common beginner project: host a simple web page

Once you can SSH in, a natural next step is to test that your server can accept inbound HTTP traffic. We’ll do something simple: run a tiny web server that serves a static page.

Choose a simple web server approach

You can use Nginx or Apache, or even a quick Python HTTP server. Beginners often start with Python because it’s straightforward. However, using Nginx is more “real-world.” Let’s do Nginx for a practical taste.

Install Nginx

On Ubuntu:

sudo apt update
sudo apt install -y nginx

Start and enable Nginx

sudo systemctl start nginx
sudo systemctl enable nginx

Test locally

On the server, check if it’s responding:

curl http://localhost

You should see HTML content or the default welcome page.

Open port 80 in the security group

Now the cloud part: if your local test works but your browser can’t connect from the internet, the security group probably blocks inbound HTTP.

Add a security group rule:

• Inbound TCP port 80
• Source: your IP or a safe range

Then reload your browser using the server’s public IP.

Edit the default page

To confirm everything is really yours (and not a random default), edit Nginx’s default page:

sudo nano /var/www/html/index.html

Put in something like “Hello from my first ECS instance!” Save and refresh your browser. If it updates, you’ve officially achieved “server wizard” status. Not full wizard. Beginner wizard. But still wizard-adjacent.

Performance and monitoring: what to look at

Beginners often treat cloud servers like a black box that either works or doesn’t. But you can learn quickly by checking a few metrics.

CPU, memory, and disk are your daily weather report

Use commands like:

• Huawei Cloud Bulk Top-up Discounts

  top

  for CPU and process usage

• free -h

  for memory

• df -h

  for disk space

For example, if you run a web server and see memory constantly near 100%, you may need a larger instance or fewer heavy processes.

Logs tell you what your server thinks happened

For Nginx, logs might be at locations like:

• /var/log/nginx/access.log
• /var/log/nginx/error.log

If your web page doesn’t load, these logs are where the truth lives. They might still be rude, but at least they are honest.

Storage and backups: don’t rely on vibes

When you start building stuff, you’ll create files, upload code, generate logs, and maybe even store data. Backups are one of those topics that sounds optional until you delete something by accident and then stare at your screen like you’re trying to reboot time.

Understand system disk vs data disk

The system disk holds the OS and maybe your initial application directories. Data disks (if you attach them) are better for storing files, databases, or anything you want to manage separately. In some platforms, data disks can be preserved more easily through certain operations, but always check the specific ECS disk behavior and policies for your configuration.

Use snapshots or backups if available

Many cloud setups support creating snapshots of disks. Snapshots help you restore to a previous state. For beginners, the key lesson is: if data matters, plan backup before you need it.

At minimum: keep your important files under version control

If you’re running code from a git repository, keep it in git. If you generate important configuration files, store them in a repo too. Then your server is less of a single point of failure.

Cost awareness: how not to accidentally fund a robot uprising

Cloud services can cost money, especially if you leave instances running. Beginners often learn this the hard way after an extended “I’ll turn it off later” phase.

Know how to stop and delete

In ECS, you’ll typically have actions like stop, start, and delete. Stopping may halt compute charges but might not stop disk charges, depending on the pricing model. Deleting usually removes the instance and often the associated resources (again, depends on exact configuration).

If you’re done with a learning instance, make sure you understand which buttons free you from ongoing charges.

Pick small sizes for experiments

During learning, smaller instance flavors save money and reduce the risk of “oops, I launched a 64-core server to run hello world.” If you need more power later, you can often resize or create a new instance with a different size.

Common mistakes and how to avoid them

Let’s list the classic beginner errors you’ll likely encounter, plus what to do instead. Consider this the “greatest hits” compilation of cloud pain.

Mistake 1: Forgetting security group rules

Symptom: you can’t connect via SSH, or your website doesn’t load.

Fix: check security group inbound rules for the relevant ports (22 for SSH, 80/443 for web). Restrict source IP if possible.

Mistake 2: Using the wrong IP address

Symptom: “Connection refused” or “timeout,” especially if you used a private IP from your laptop.

Fix: use the public IP/EIP for external access.

Mistake 3: Losing or mismatching the SSH key

Symptom: authentication fails even though security group allows it.

Fix: verify you used the correct private key corresponding to the key pair assigned at creation.

Mistake 4: Assuming you can connect immediately

Symptom: SSH fails while the instance is still provisioning.

Fix: wait until the instance status shows ready/running/healthy.

Mistake 5: Leaving services running without thought

Symptom: unnecessary cost or performance impact.

Fix: after learning, stop or delete instances as appropriate; review running services and logs.

Scaling up later: what beginners should know next

Once your first ECS instance works, you may wonder: “Okay, now what?” The good news is ECS supports growth paths.

Resize instance resources

If you need more CPU or memory, you can often adjust the instance size. This is useful when your application grows.

Add more storage

Huawei Cloud Bulk Top-up Discounts If disk space runs out, you can expand storage or attach a separate data disk depending on available features and your current setup.

Use load balancers for production-style setups

When you move beyond learning and start serving real traffic, you typically introduce a load balancer and possibly multiple ECS instances behind it. That way, one server doesn’t carry the whole show like it’s starring in a one-person theater production.

Huawei Cloud Bulk Top-up Discounts Mini-checklist: your “I successfully created ECS” recap

Here’s a compact recap so you can verify your progress. If you can check these boxes, you’re doing great:

• You created an ECS instance with a Linux image
• You selected an appropriate instance size
• You configured networking with a VPC/subnet
• You set authentication (SSH key pair recommended)
• You configured inbound security group rules (SSH at least)
• Your instance is running and you can SSH into it
• You can run a basic command and see system info
• You optionally tested a simple web server and opened port 80

Troubleshooting scenarios you’ll probably face (and how to respond)

Let’s walk through a few realistic scenarios. Not because your server is trying to sabotage you, but because cloud environments have enough moving parts to keep a detective busy.

Scenario: “My browser can’t load the website, but Nginx is running.”

What’s likely happening: Nginx is serving locally, but inbound traffic on port 80 is blocked.

What to do:

• Check Nginx status:

  sudo systemctl status nginx

• Confirm local response:

  curl http://localhost

• Huawei Cloud Bulk Top-up Discounts In the security group, add inbound rule for TCP 80 from your IP
• Verify you’re visiting the public IP (not a private IP)

Scenario: “SSH times out.”

What’s likely happening: security group blocks port 22, public IP is wrong, or the instance isn’t ready.

What to do:

• Confirm instance status is running
• Check public IP field
• Ensure inbound rule: TCP 22 from your IP
• Double-check you’re using the correct SSH username
• Try again after a few minutes if it was still provisioning

Scenario: “SSH says ‘Permission denied’.”

What’s likely happening: wrong key or wrong username.

What to do:

• Make sure you used the private key that matches the key pair
• Check file permissions (chmod 600)
• Verify OS default username for your chosen image

Final thoughts: you’ve got this

Getting started with Huawei Cloud ECS isn’t hard, but it is a little like assembling furniture. Most of the time, it’s straightforward; sometimes you realize you skipped a step; and occasionally you’re left holding a screw with no obvious home. That’s okay. Cloud learning is iterative. Create an instance, connect, test something small, adjust security rules, and repeat.

If you follow this tutorial, you’ll have your first ECS instance running and you’ll understand the basic pieces: image, instance size, networking, authentication, security groups, and connection methods. And the next time you see an error message, you’ll know it’s not fate—it’s just feedback from a system with excellent documentation (and sometimes dramatic silence).

When you’re ready for more, consider practicing: deploy a small app, set up HTTPS with a certificate (if you’re comfortable), add automated updates, configure basic monitoring, and plan backups. For now, celebrate the best beginner milestone: successfully creating and connecting to your server without summoning the cloud goblins.