fc-java-website

Files (2)

• .bundled-hash
• SKILL.md

SKILL.md (first lines)

# Deploy a Java website on function-compute / 在 function-compute 上部署 Java 网站

## AutoClaw managed-delivery boundary (highest priority) / 受控交付边界（最高优先级）

When `website_delivery_start` or `AUTOCLAW_FUNCTION_COMPUTE_WEBSITE_PROTOCOL`
is active, **do not call `/functionCompute`, read/request/store/output a JWT, or
execute this Skill's curl commands.** API sections are reference-only. Build,
package, and verify the artifact locally; AutoClaw Main owns create/upload, and
the human owns publication. The current managed automatic-preview path supports
nginx only, so do not add an nginx `autoPreview` marker for a Java package.

当 `website_delivery_start` 或 `AUTOCLAW_FUNCTION_COMPUTE_WEBSITE_PROTOCOL`
生效时，**禁止调用 `/functionCompute`、读取/索取/保存/输出 JWT，禁止执行本 Skill 的 curl。**
API 章节仅作参考；Agent 只负责本地构建、打包与验证，创建和上传由 AutoClaw Main 负责，
正式发布由用户负责。当前自动预览仅支持 nginx，Java 产物不得写 nginx `autoPreview` 标记。

## English

### 1. What the `java` environment is

The `java` environment runs on the **Aliyun FC 3.0 built-in `java11` runtime**. It is
**handler-based** (not a long-running server): FC invokes one method per HTTP request.

> **CRITICAL — this runtime does NOT compile source.** You MUST ship **compiled
> bytecode** (`.class` files). Shipping `App.java` as source returns **HTTP 502**. The
> deployable artifact is a zip of compiled classes, e.g. `example/App.class` at the zip
> root.

| Property | Value |
| --- | --- |
| Runtime | `java11` (built-in, Java 11) |
| Handler | `example.App::handleRequest` (fixed by the preset) |
| Memory | 512 MB |
| CPU | 0.35 vCPU |
| Disk | 512 MB |
| Timeout | 60 s per request |
| Instance concurrency | 1 |
| Code location | Extracted to `/code` inside the instance |
| Classpath | `/code` plus `/code/lib/*.jar` |
| Port | none — this is a handler runtime, do NOT open a socket |

Constraints to respect:
- **Ship compiled `.class`, never `.java`.** The built-in runtime executes your bytecode;
  it does not run a compiler. A source zip fails with HTTP 502.
- The handler string is **`example.App::handleRequest`**. Your compiled class must be
  `example.App`, implementing `com.aliyun.fc.runtime.StreamRequestHandler`. Do not rename
  it unless you also change the function's handler (the preset does not).
- One request per instance (concurrency 1); keep per-request work under the 60 s timeout.
- No inbound port and no custom start command — FC calls your method directly.

### 2. The handler contract

Your class **must implement `com.aliyun.fc.runtime.StreamRequestHandler`** and override:

```java
void handleRequest(InputStream input, OutputStream output, Context context)
```

- **`fc-java-core` is PROVIDED by the FC java11 runtime.** `com.aliyun.fc.runtime.Context`
  and `com.aliyun.fc.runtime.StreamRequestHandler` exist on the runtime classpath. **Do
  NOT bundle `fc-java-core`** in your zip — only compile against it (as a `provided`
  Maven dependency, or against a tiny stub of the two interfaces) and ship your own class.
- The request arrives as the **v1 event JSON** on the `InputStream`.
- You write the **v1 response JSON** — `{statusCode, headers, body, isBase64Encoded}` —
  as UTF-8 bytes to the `OutputStream`, then flush.

Response JSON fields:
- `statusCode` — integer HTTP status.
- `headers` — object of response headers (set `content-type`).
- `body` — the response body as a string (HTML/JSON/text). Escape it inside the JSON.
- `isBase64Encoded` — `true` if `body` is base64-encoded binary; `false` for text.

### 3. Verified working example (use verbatim)

This exact class is what the platform's built-in Java example ships as a compiled
`App.class`, and it is verified to return **HTTP 200**:

```java
package example;
import com.aliyun.fc.runtime.Context;
import com.aliyun.fc.runtime.StreamRequestHandler;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
public class App implements StreamRequestHandler {
    @Override
    public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException {
        String html = "<html><body><h1>Hello from Function Compute (Java)</h1></body></html>";
        String body = html.replace("\\", "\\\\").replace("\"", "\\\"");
        String resp = "{\"statusCode\":200,\"headers\":{\"content-type\":\"text/html; charset=utf-8\"},\"body\":\"" + body + "\",\"isBase64Encoded\":false}";
        output.write(resp.getBytes(StandardCharsets.UTF_8));
        output.flush();
    }
}
```

### 4. File-structure contract

The uploaded `.zip` must contain **compiled classes** that satisfy the
`example.App::handleRequest` handler — `example.App` implementing
`StreamRequestHandler`. Put your compiled `example/App.class` at the **zip root** (it
extracts to `/code/example/App.class`). The classpath is rooted at `/code` plus
`/code/lib/*.jar`, so dependency jars go under `lib/`. **No `App.java`. No bundled
`fc-java-core`.**

```
your.zip
├── example/
│   └── App.class          # compiled example.App (implements StreamRequestHandler)
└── lib/                   # optional: your dependency jars on the classpath
    └── *.jar              # do NOT put fc-java-core here — it is provided by the runtime
```

The zip is valid as long as the compiled class `example.App` (with the
`handleRequest(InputStream, OutputStream, Context)` method) resolves on the runtime
classpath rooted at `/code`.

### 5. Build recipe

From Reyvic925/tradingwebsite, MIT.

More from Reyvic925/tradingwebsite