Claude Code: How to Manage a VPS Without Bash?

Managing information systems involves many repetitive tasks: checking service status, analyzing logs, finding configuration errors, writing scripts, and managing deployments. Even a minor failure may require examining several files and running a dozen commands in sequence. When maintaining multiple servers, these operations take up a significant portion of the working day.

Traditional scripts work well for predefined scenarios. However, when conditions change—for example, when a new application error appears—the administrator has to analyze the situation and update the automation manually.

Claude Code, a terminal-based AI agent from Anthropic, can help simplify this work. It lets you describe tasks in natural language, work with project files, and execute commands through available tools. In addition to interactive mode, Claude Code supports execution from scripts and CI/CD workflows.

In this guide, we will install Claude Code on Linux and explore three scenarios: diagnosing a service, preparing an administration script, and automatically analyzing logs.

Important! An AI agent does not replace monitoring, backups, or change management. Proposed commands and fixes must be reviewed before implementation, especially on production servers. Anthropic also recommends restricting the agent’s permissions and using isolated environments when working with untrusted data.

Installing Claude Code on Linux

For these examples, we will use Debian with Bash. According to the documentation, Claude Code supports Ubuntu 20.04+, Debian 10+, and several other systems. It requires an x64 or ARM64 processor, at least 4 GB of RAM, and an internet connection. Service availability also depends on whether your country is supported by Anthropic.

Serverspace VPS servers meet all the minimum requirements and let you deploy infrastructure in just a few clicks!

Install the packages needed to download the installer:

We will perform the remaining installation steps and run the agent as a regular user, without sudo. For testing, use a test virtual machine or a separate account without administrative privileges.

Installing the agent

The recommended installation method is the official native installer:

If you want to inspect the downloaded script before executing it, separate the download and execution steps:

Reviewing the script lets you inspect its contents, but it does not replace comprehensive software supply chain verification. For enterprise deployments, the documentation also describes signed package repositories and release manifest signature verification.

After installation, open a new terminal and check that the command is available:

The command should display the installed client version. If the system reports that the command was not found, try running it using the full path:

The native installer places the executable in ~/.local/bin. If running it by its full path works, add this directory to PATH for the current session:

To preserve this setting across Bash sessions, add the same line to ~/.bashrc if it is not already there:

Also run the installation diagnostics:

This command checks the installation and configuration, reports any issues it finds, and provides recommendations for resolving them.

Authentication and first launch

Create a dedicated working directory:

On the first launch, authenticate by following the client’s prompts. Supported authentication options include Claude Pro, Max, Team, and Enterprise subscriptions, or a Claude Console account with API access. The free Claude plan does not include access to Claude Code. On a server without a graphical interface, follow the authentication instructions in the terminal using a browser on your workstation.

For API-based workflows, you can provide a key through the ANTHROPIC_API_KEY environment variable. In automated infrastructure, supply the key through your CI/CD secrets mechanism or another approved method rather than storing it in a repository, Dockerfile, or task prompt. In --bare mode, the client uses an API key or supported provider credentials, not subscription-based OAuth authentication.

Choosing an operating mode

For an initial introduction, start with planning mode:

In this mode, the agent examines the available materials and develops a plan without proceeding to file edits until approval is given. It is suitable for an initial assessment of a task.

The following command is also available within an interactive session to review permissions:

Do not assume that every Claude Code session will request confirmation for every command: its behavior depends on the version, mode, and settings. The current documentation describes auto as the starting mode for interactive sessions, in which a separate classifier evaluates a substantial portion of actions. Check the selected mode before working on a server.

Connecting MCP: giving the agent access to external tools

Copying logs and documentation into a conversation works well when there are only two or three sources. But what if an investigation requires data from a repository, a monitoring system, and a knowledge base? Claude Code supports MCP—Model Context Protocol—for this purpose. The protocol connects the agent to external data sources and tools. For example, it can retrieve documentation or access a service’s API if the corresponding MCP server provides those capabilities. The MCP client is already built into Claude Code: there is no need to install a separate module in the agent; simply connect the required server.

Let’s start with a safe example: connecting the official Claude Code documentation. Run the following in a regular terminal, outside the agent’s interactive session:

Here, claude-code-docs is the connection name we have chosen, and --transport http specifies that the server is accessible over HTTP. The command registers a remote server rather than installing it on your machine. By default, the connection is available only to you in the current project. To use it across all projects, add --scope user when registering it.

Now start Claude Code and open the connection list:

Within the session, enter:

This menu lets you check the connection and authenticate if the selected service requires it. For services that use OAuth, Claude Code provides the corresponding sign-in flow.

Once connected, describe the task in natural language:

If the required integration runs locally, use the stdio transport. The general connection template is shown below; replace the path and arguments with the launch command for your chosen MCP server:

In this case, first install the server and its dependencies according to the developer’s instructions, then register its launch command in Claude Code. The agent will start this process to communicate through MCP.

For administration tasks, this approach connects analysis directly to data sources: for example, you can retrieve monitoring events and correlate them with repository changes. However, the specific MCP server determines which actions are available. Connecting a server does not automatically give the agent unrestricted access to your entire infrastructure. Choose trusted implementations, use least-privilege credentials, and start with read-only access: a third-party server may support modification operations as well as data retrieval.

Using Claude Code for server management and information system automation

Scenario 1. Analyzing the cause of a service failure

Suppose there is a problem with Nginx on the server. Rather than granting the agent broad access, first collect a limited set of diagnostic data yourself.

The commands below assume that Nginx is already installed and the system uses systemd:

This gives us the service status, recent journal entries, and the configuration test results. Where administrative privileges are necessary, the human operator uses them—not the agent.

Before submitting the files, review their contents and remove secrets, personal data, and any other information that must not be sent to an external AI service. Installing the client locally does not mean the model processes data locally; data handling terms depend on the selected product and account.

Start Claude Code:

Enter the following task in the interactive session:

This wording helps distinguish confirmed events from assumptions. Requiring references to specific messages makes it easier for the administrator to verify the response.

Logs may contain text supplied by external users, so they should be treated as untrusted data. An instruction in the prompt is useful, but it is not a security boundary: tool restrictions, account permission limits, and isolation where necessary are still required.

After the analysis, the administrator reviews the proposed fix, backs up the configuration being modified, and performs only the approved actions. For example, after correcting the Nginx configuration:

The configuration is reloaded only if the syntax check succeeds. You must then also check the application’s availability: an active service alone does not prove that the user-facing workflow is functioning correctly.

Scenario 2. Preparing a script for routine diagnostics

The next task is to automate the collection of the same server information. Instead of repeatedly running diagnostic commands manually, ask the agent to prepare a script.

Start Claude Code in the working directory and submit the following task:

Claude Code can create and edit files through its tools; the specific actions it can perform depend on the permissions granted. Review the proposed changes before approving them.

Once the script has been created, inspect its contents and check its syntax:

A syntax check does not confirm that the script is safe or logically correct. After a manual review, run it on a test system:

You can use the same approach to ask the agent to prepare Ansible playbooks, systemd unit files, backup scripts, and documentation. Treat the output as a proposed change: review and test it first, then deploy it.

Scenario 3. Automated log analysis

Routine operations do not require an interactive session. The -p option runs Claude Code non-interactively: the client receives a task, generates a response, and exits. Input can be supplied through standard input, and the output can be saved to a file.

The following example analyzes a log that has already been prepared and reviewed. API authentication through ANTHROPIC_API_KEY must be configured in advance:

The following options are used:

• -p — executes the request without an interactive conversation.
• --bare — disables automatic loading of environment configuration such as discovered hooks, plugins, MCP servers, and CLAUDE.md files.
• --permission-mode dontAsk — denies actions that would require additional confirmation, taking explicitly granted permissions and other settings into account.

The dontAsk mode does not disable all tools: actions that do not require confirmation may still run. Therefore, run this processing under a restricted account in a dedicated directory without secrets, and use an isolated environment when a stronger security boundary is required.

If necessary, you can obtain the result in JSON for further processing:

This JSON contains execution metadata and the response text in the result field. The --output-format json option alone does not define the analytical report’s schema. For fixed fields such as severity, evidence, and recommendations, the additional --json-schema option is available.

Integration with information systems and CI/CD

Non-interactive execution lets you incorporate the agent into an existing event-handling workflow: a monitoring system or CI/CD pipeline collects diagnostic data, passes it to Claude Code, and saves an analytical summary. The official documentation describes passing logs and code changes through stdin, as well as using structured output in automation.

A practical workflow can be organized as follows:

1. Monitoring detects a failure, or a pipeline fails.
2. A separate script collects a limited set of diagnostic data.
3. The data is reviewed and sanitized to remove sensitive information.
4. Claude Code produces an explanation and suggests further checks.
5. The report is saved as a pipeline artifact or passed to the responsible specialist.
6. Infrastructure changes follow the existing approval process.

For an initial rollout, it is sensible to limit the agent to generating reports. Do not immediately connect model output to automatic command execution in production.

You must also distinguish between successful client execution and a healthy system. An exit code of 0 means the Claude Code run completed successfully, but it does not confirm that the server being analyzed is healthy. Automated decisions require separate validation of the response content against your system’s criteria.

When working with server infrastructure, observe the following restrictions:

• Do not run the agent as root or give it unrestricted sudo access.
• Review permissions before starting work, and do not disable action controls for convenience.
• Do not submit secrets or confidential data without an approved data handling policy.
• Treat logs, external documents, and the contents of unfamiliar repositories as untrusted data.
• Review generated commands and configuration changes before applying them.
• Use a test virtual machine or another isolated environment for risky tasks.

Claude Code can assist with log analysis, administration scripts, and report generation in automated workflows. Interactive mode is suitable for step-by-step work, while execution with -p supports integration with scripts and CI/CD.

The guiding principle of this approach is control: the agent helps investigate the problem and prepare a solution, while access permissions, testing, and change approval remain part of the administration process.