Implementierung eines Auftragsverarbeitungssystems: Teil Gründung der Stiftung

1. Einführung und Ziele

Willkommen zum ersten Teil unserer umfassenden Blogserie über die Implementierung eines anspruchsvollen Auftragsverarbeitungssystems mit Temporal für die Microservice-Orchestrierung. In dieser Serie untersuchen wir die Feinheiten des Aufbaus eines robusten, skalierbaren und wartbaren Systems, das komplexe, lang andauernde Arbeitsabläufe bewältigen kann.

Unsere Reise beginnt mit der Schaffung des Grundsteins für unser Projekt. Am Ende dieses Beitrags verfügen Sie über eine voll funktionsfähige CRUD-REST-API, die in Golang implementiert, in Temporal für die Workflow-Orchestrierung integriert und durch eine Postgres-Datenbank gestützt ist. Wir verwenden moderne Tools und Best Practices, um sicherzustellen, dass unsere Codebasis sauber, effizient und leicht zu warten ist.

Ziele für diesen Beitrag:

1. Erstellen Sie ein gut strukturiertes Projekt mit Go-Modulen
2. Implementieren Sie eine grundlegende CRUD-API mit Gin und oapi-codegen
3. Richten Sie eine Postgres-Datenbank ein und implementieren Sie Migrationen
4. Erstellen Sie einen einfachen zeitlichen Workflow mit Datenbankinteraktion
5. Implementieren Sie die Abhängigkeitsinjektion für eine bessere Testbarkeit und Wartbarkeit
6. Containerisieren Sie unsere Anwendung mit Docker
7. Stellen Sie mit Docker-Compose eine vollständige lokale Entwicklungsumgebung bereit

Lassen Sie uns eintauchen und mit dem Aufbau unseres Auftragsabwicklungssystems beginnen!

2. Theoretischer Hintergrund und Konzepte

Bevor wir mit der Implementierung beginnen, werfen wir einen kurzen Blick auf die wichtigsten Technologien und Konzepte, die wir verwenden werden:

Golang

Go ist eine statisch typisierte, kompilierte Sprache, die für ihre Einfachheit, Effizienz und hervorragende Unterstützung für gleichzeitige Programmierung bekannt ist. Seine Standardbibliothek und sein robustes Ökosystem machen es zu einer ausgezeichneten Wahl für den Aufbau von Microservices.

Zeitlich

Temporal ist eine Microservice-Orchestrierungsplattform, die die Entwicklung verteilter Anwendungen vereinfacht. Es ermöglicht uns, komplexe, langwierige Arbeitsabläufe als einfachen prozeduralen Code zu schreiben und Fehler und Wiederholungsversuche automatisch zu behandeln.

Gin Web Framework

Gin ist ein leistungsstarkes HTTP-Webframework, das in Go geschrieben wurde. Es bietet eine Martini-ähnliche API mit viel besserer Leistung und geringerer Speichernutzung.

OpenAPI und oapi-codegen

OpenAPI (früher bekannt als Swagger) ist eine Spezifikation für maschinenlesbare Schnittstellendateien zur Beschreibung, Produktion, Nutzung und Visualisierung von RESTful-Webdiensten. oapi-codegen ist ein Tool, das Go-Code aus OpenAPI 3.0-Spezifikationen generiert, sodass wir zuerst unseren API-Vertrag definieren und Server-Stubs und Client-Code generieren können.

sqlc

sqlc generiert typsicheren Go-Code aus SQL. Es ermöglicht uns, einfache SQL-Abfragen zu schreiben und vollständig typsicheren Go-Code für die Interaktion mit unserer Datenbank zu generieren, wodurch die Wahrscheinlichkeit von Laufzeitfehlern verringert und die Wartbarkeit verbessert wird.

Postgres

PostgreSQL ist ein leistungsstarkes, objektrelationales Open-Source-Datenbanksystem, das für seine Zuverlässigkeit, Funktionsrobustheit und Leistung bekannt ist.

Docker und Docker-Compose

Docker ermöglicht es uns, unsere Anwendung und ihre Abhängigkeiten in Container zu packen und so die Konsistenz in verschiedenen Umgebungen sicherzustellen. docker-compose ist ein Tool zum Definieren und Ausführen von Docker-Anwendungen mit mehreren Containern, mit dem wir unsere lokale Entwicklungsumgebung einrichten.

Da wir uns nun mit den Grundlagen befasst haben, beginnen wir mit der Implementierung unseres Systems.

3. Schritt-für-Schritt-Anleitung zur Implementierung

3.1 Einrichten der Projektstruktur

Erstens erstellen wir unser Projektverzeichnis und richten die Grundstruktur ein:

mkdir order-processing-system
cd order-processing-system

# Create directory structure
mkdir -p cmd/api \
         internal/api \
         internal/db \
         internal/models \
         internal/service \
         internal/workflow \
         migrations \
         pkg/logger \
         scripts

# Initialize Go module
go mod init github.com/yourusername/order-processing-system

# Create main.go file
touch cmd/api/main.go

Diese Struktur folgt dem Standard-Go-Projektlayout:

• cmd/api: Enthält den Haupteinstiegspunkt der Anwendung
• intern: Enthält Pakete, die spezifisch für dieses Projekt sind und nicht für den Import durch andere Projekte gedacht sind
• Migrationen: Speichert Datenbankmigrationsdateien
• pkg: Enthält Pakete, die von anderen Projekten importiert werden können
• Skripte: Enthält Dienstprogrammskripte für Entwicklung und Bereitstellung

3.2 Erstellen des Makefiles

Lassen Sie uns ein Makefile erstellen, um häufige Aufgaben zu vereinfachen:

touch Makefile

Fügen Sie den folgenden Inhalt zum Makefile hinzu:

.PHONY: generate build run test clean

generate:
    @echo "Generating code..."
    go generate ./...

build:
    @echo "Building..."
    go build -o bin/api cmd/api/main.go

run:
    @echo "Running..."
    go run cmd/api/main.go

test:
    @echo "Running tests..."
    go test -v ./...

clean:
    @echo "Cleaning..."
    rm -rf bin

.DEFAULT_GOAL := build

Dieses Makefile bietet Ziele zum Generieren von Code, zum Erstellen der Anwendung, zum Ausführen, zum Ausführen von Tests und zum Bereinigen von Build-Artefakten.

3.3 Implementierung der Basic CRUD API

3.3.1 Definieren Sie die OpenAPI-Spezifikation

Erstellen Sie eine Datei mit dem Namen api/openapi.yaml und definieren Sie unsere API-Spezifikation:

openapi: 3.0.0
info:
  title: Order Processing API
  version: 1.0.0
  description: API for managing orders in our processing system

paths:
  /orders:
    get:
      summary: List all orders
      responses:
        '200':
          description: Successful response
          content:
            application/json:    
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Order'
    post:
      summary: Create a new order
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateOrderRequest'
      responses:
        '201':
          description: Created
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Order'

  /orders/{id}:
    get:
      summary: Get an order by ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Order'
        '404':
          description: Order not found
    put:
      summary: Update an order
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UpdateOrderRequest'
      responses:
        '200':
          description: Successful response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Order'
        '404':
          description: Order not found
    delete:
      summary: Delete an order
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: integer
      responses:
        '204':
          description: Successful response
        '404':
          description: Order not found

components:
  schemas:
    Order:
      type: object
      properties:
        id:
          type: integer
        customer_id:
          type: integer
        status:
          type: string
          enum: [pending, processing, completed, cancelled]
        total_amount:
          type: number
        created_at:
          type: string
          format: date-time
        updated_at:
          type: string
          format: date-time
    CreateOrderRequest:
      type: object
      required:
        - customer_id
        - total_amount
      properties:
        customer_id:
          type: integer
        total_amount:
          type: number
    UpdateOrderRequest:
      type: object
      properties:
        status:
          type: string
          enum: [pending, processing, completed, cancelled]
        total_amount:
          type: number

Diese Spezifikation definiert unsere grundlegenden CRUD-Operationen für Bestellungen.

3.3.2 API-Code generieren

OAPI-Codegen installieren:

go install github.com/deepmap/oapi-codegen/cmd/oapi-codegen@latest

Generate the server code:

oapi-codegen -package api -generate types,server,spec api/openapi.yaml > internal/api/api.gen.go

This command generates the Go code for our API, including types, server interfaces, and the OpenAPI specification.

3.3.3 Implement the API Handler

Create a new file internal/api/handler.go:

package api

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

type Handler struct {
    // We'll add dependencies here later
}

func NewHandler() *Handler {
    return &Handler{}
}

func (h *Handler) RegisterRoutes(r *gin.Engine) {
    RegisterHandlers(r, h)
}

// Implement the ServerInterface methods

func (h *Handler) GetOrders(c *gin.Context) {
    // TODO: Implement
    c.JSON(http.StatusOK, []Order{})
}

func (h *Handler) CreateOrder(c *gin.Context) {
    var req CreateOrderRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // TODO: Implement order creation logic
    order := Order{
        Id: 1,
        CustomerId: req.CustomerId,
        Status: "pending",
        TotalAmount: req.TotalAmount,
    }

    c.JSON(http.StatusCreated, order)
}

func (h *Handler) GetOrder(c *gin.Context, id int) {
    // TODO: Implement
    c.JSON(http.StatusOK, Order{Id: id})
}

func (h *Handler) UpdateOrder(c *gin.Context, id int) {
    var req UpdateOrderRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // TODO: Implement order update logic
    order := Order{
        Id: id,
        Status: *req.Status,
    }

    c.JSON(http.StatusOK, order)
}

func (h *Handler) DeleteOrder(c *gin.Context, id int) {
    // TODO: Implement
    c.Status(http.StatusNoContent)
}

This implementation provides a basic structure for our API handlers. We’ll flesh out the actual logic when we integrate with the database and Temporal workflows.

3.4 Setting Up the Postgres Database

3.4.1 Create a docker-compose file

Create a docker-compose.yml file in the project root:

version: '3.8'

services:
  postgres:
    image: postgres:13
    environment:
      POSTGRES_USER: orderuser
      POSTGRES_PASSWORD: orderpass
      POSTGRES_DB: orderdb
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

This sets up a Postgres container for our local development environment.

3.4.2 Implement Database Migrations

Install golang-migrate:

go install -tags 'postgres' github.com/golang-migrate/migrate/v4/cmd/migrate@latest

Create our first migration:

migrate create -ext sql -dir migrations -seq create_orders_table

Edit the migrations/000001_create_orders_table.up.sql file:

CREATE TABLE orders (
    id SERIAL PRIMARY KEY,
    customer_id INTEGER NOT NULL,
    status VARCHAR(20) NOT NULL,
    total_amount DECIMAL(10, 2) NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
);

CREATE INDEX idx_orders_customer_id ON orders(customer_id);
CREATE INDEX idx_orders_status ON orders(status);

Edit the migrations/000001_create_orders_table.down.sql file:

DROP TABLE IF EXISTS orders;

3.4.3 Run Migrations

Add a new target to our Makefile:

migrate-up:
    @echo "Running migrations..."
    migrate -path migrations -database "postgresql://orderuser:orderpass@localhost:5432/orderdb?sslmode=disable" up

migrate-down:
    @echo "Reverting migrations..."
    migrate -path migrations -database "postgresql://orderuser:orderpass@localhost:5432/orderdb?sslmode=disable" down

Now we can run migrations with:

make migrate-up

3.5 Implementing Database Operations with sqlc

3.5.1 Install sqlc

go install github.com/kyleconroy/sqlc/cmd/sqlc@latest

3.5.2 Configure sqlc

Create a sqlc.yaml file in the project root:

version: "2"
sql:
  - engine: "postgresql"
    queries: "internal/db/queries.sql"
    schema: "migrations"
    gen:
      go:
        package: "db"
        out: "internal/db"
        emit_json_tags: true
        emit_prepared_queries: false
        emit_interface: true
        emit_exact_table_names: false

3.5.3 Write SQL Queries

Create a file internal/db/queries.sql:

-- name: GetOrder :one
SELECT * FROM orders
WHERE id = $1 LIMIT 1;

-- name: ListOrders :many
SELECT * FROM orders
ORDER BY id;

-- name: CreateOrder :one
INSERT INTO orders (
  customer_id, status, total_amount
) VALUES (
  $1, $2, $3
)
RETURNING *;

-- name: UpdateOrder :one
UPDATE orders
SET status = $2, total_amount = $3, updated_at = CURRENT_TIMESTAMP
WHERE id = $1
RETURNING *;

-- name: DeleteOrder :exec
DELETE FROM orders
WHERE id = $1;

3.5.4 Generate Go Code

Add a new target to our Makefile:

generate-sqlc:
    @echo "Generating sqlc code..."
    sqlc generate

Run the code generation:

make generate-sqlc

This will generate Go code for interacting with our database in the internal/db directory.

3.6 Integrating Temporal

3.6.1 Set Up Temporal Server

Add Temporal to our docker-compose.yml:

  temporal:
    image: temporalio/auto-setup:1.13.0
    ports:
      - "7233:7233"
    environment:
      - DB=postgresql
      - DB_PORT=5432
      - POSTGRES_USER=orderuser
      - POSTGRES_PWD=orderpass
      - POSTGRES_SEEDS=postgres
    depends_on:
      - postgres

  temporal-admin-tools:
    image: temporalio/admin-tools:1.13.0
    depends_on:
      - temporal

3.6.2 Implement a Basic Workflow

Create a file internal/workflow/order_workflow.go:

package workflow

import (
    "time"

    "go.temporal.io/sdk/workflow"
    "github.com/yourusername/order-processing-system/internal/db"
)

func OrderWorkflow(ctx workflow.Context, order db.Order) error {
    logger := workflow.GetLogger(ctx)
    logger.Info("OrderWorkflow started", "OrderID", order.ID)

    // Simulate order processing
    err := workflow.Sleep(ctx, 5*time.Second)
    if err != nil {
        return err
    }

    // Update order status
    err = workflow.ExecuteActivity(ctx, UpdateOrderStatus, workflow.ActivityOptions{
        StartToCloseTimeout: time.Minute,
    }, order.ID, "completed").Get(ctx, nil)
    if err != nil {
        return err
    }

    logger.Info("OrderWorkflow completed", "OrderID", order.ID)
    return nil
}

func UpdateOrderStatus(ctx workflow.Context, orderID int64, status string) error {
    // TODO: Implement database update
    return nil
}

This basic workflow simulates order processing by waiting for 5 seconds and then updating the order status to “completed”.

3.6.3 Integrate Workflow with API

Update the internal/api/handler.go file to include Temporal client and start the workflow:

package api

import (
    "context"
    "net/http"

    "github.com/gin-gonic/gin"
    "go.temporal.io/sdk/client"
    "github.com/yourusername/order-processing-system/internal/db"
    "github.com/yourusername/order-processing-system/internal/workflow"
)

type Handler struct {
    queries *db.Queries
    temporalClient client.Client
}

func NewHandler(queries *db.Queries, temporalClient client.Client) *Handler {
    return &Handler{
        queries: queries,
        temporalClient: temporalClient,
    }
}

// ... (previous handler methods)

func (h *Handler) CreateOrder(c *gin.Context) {
    var req CreateOrderRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    order, err := h.queries.CreateOrder(c, db.CreateOrderParams{
        CustomerID: req.CustomerId,
        Status: "pending",
        TotalAmount: req.TotalAmount,
    })
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    // Start Temporal workflow
    workflowOptions := client.StartWorkflowOptions{
        ID: "order-" + order.ID,
        TaskQueue: "order-processing",
    }
    _, err = h.temporalClient.ExecuteWorkflow(context.Background(), workflowOptions, workflow.OrderWorkflow, order)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to start workflow"})
        return
    }

    c.JSON(http.StatusCreated, order)
}

// ... (implement other handler methods)

3.7 Implementing Dependency Injection

Create a new file internal/service/service.go:

package service

import (
    "database/sql"

    "github.com/yourusername/order-processing-system/internal/api"
    "github.com/yourusername/order-processing-system/internal/db"
    "go.temporal.io/sdk/client"
)

type Service struct {
    DB *sql.DB
    Queries *db.Queries
    TemporalClient client.Client
    Handler *api.Handler
}

func NewService() (*Service, error) {
    // Initialize database connection
    db, err := sql.Open("postgres", "postgresql://orderuser:orderpass@localhost:5432/orderdb?sslmode=disable")
    if err != nil {
        return nil, err
    }

    // Initialize Temporal client
    temporalClient, err := client.NewClient(client.Options{
        HostPort: "localhost:7233",
    })
    if err != nil {
        return nil, err
    }

    // Initialize queries
    queries := db.New(db)

    // Initialize handler
    handler := api.NewHandler(queries, temporalClient)

    return &Service{
        DB: db,
        Queries: queries,
        TemporalClient: temporalClient,
        Handler: handler,
    }, nil
}

func (s *Service) Close() {
    s.DB.Close()
    s.TemporalClient.Close()
}

3.8 Update Main Function

Update the cmd/api/main.go file:

package main

import (
    "log"

    "github.com/gin-gonic/gin"
    _ "github.com/lib/pq"
    "github.com/yourusername/order-processing-system/internal/service"
)

func main() {
    svc, err := service.NewService()
    if err != nil {
        log.Fatalf("Failed to initialize service: %v", err)
    }
    defer svc.Close()

    r := gin.Default()
    svc.Handler.RegisterRoutes(r)

    if err := r.Run(":8080"); err != nil {
        log.Fatalf("Failed to run server: %v", err)
    }
}

3.9 Dockerize the Application

Create a Dockerfile in the project root:

# Build stage
FROM golang:1.17-alpine AS build

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -o /order-processing-system ./cmd/api

# Run stage
FROM alpine:latest

WORKDIR /

COPY --from=build /order-processing-system /order-processing-system

EXPOSE 8080

ENTRYPOINT ["/order-processing-system"]

Update the docker-compose.yml file to include our application:

version: '3.8'

services:
  postgres:
    # ... (previous postgres configuration)

  temporal:
    # ... (previous temporal configuration)

  temporal-admin-tools:
    # ... (previous temporal-admin-tools configuration)

  app:
    build: .
    ports:
      - "8080:8080"
    depends_on:
      - postgres
      - temporal
    environment:
      - DB_HOST=postgres
      - DB_USER=orderuser
      - DB_PASSWORD=orderpass
      - DB_NAME=orderdb
      - TEMPORAL_HOST=temporal:7233

4. Code Examples with Detailed Comments

Throughout the implementation guide, we’ve provided code snippets with explanations. Here’s a more detailed look at a key part of our system: the Order Workflow.

package workflow

import (
    "time"

    "go.temporal.io/sdk/workflow"
    "github.com/yourusername/order-processing-system/internal/db"
)

// OrderWorkflow defines the workflow for processing an order
func OrderWorkflow(ctx workflow.Context, order db.Order) error {
    logger := workflow.GetLogger(ctx)
    logger.Info("OrderWorkflow started", "OrderID", order.ID)

    // Simulate order processing
    // In a real-world scenario, this could involve multiple activities such as
    // inventory check, payment processing, shipping arrangement, etc.
    err := workflow.Sleep(ctx, 5*time.Second)
    if err != nil {
        return err
    }

    // Update order status
    // We use ExecuteActivity to run the status update as an activity
    // This allows for automatic retries and error handling
    err = workflow.ExecuteActivity(ctx, UpdateOrderStatus, workflow.ActivityOptions{
        StartToCloseTimeout: time.Minute,
    }, order.ID, "completed").Get(ctx, nil)
    if err != nil {
        return err
    }

    logger.Info("OrderWorkflow completed", "OrderID", order.ID)
    return nil
}

// UpdateOrderStatus is an activity that updates the status of an order
func UpdateOrderStatus(ctx workflow.Context, orderID int64, status string) error {
    // TODO: Implement database update
    // In a real implementation, this would use the db.Queries to update the order status
    return nil
}

This workflow demonstrates several key concepts:

1. Use of Temporal’s workflow.Context for managing the workflow lifecycle.
2. Logging within workflows using workflow.GetLogger.
3. Simulating long-running processes with workflow.Sleep.
4. Executing activities within a workflow using workflow.ExecuteActivity.
5. Handling errors and returning them to be managed by Temporal.

5. Testing and Validation

For this initial setup, we’ll focus on manual testing to ensure our system is working as expected. In future posts, we’ll dive into unit testing, integration testing, and end-to-end testing strategies.

To manually test our system:

1. Start the services:

docker-compose up

1. Use a tool like cURL or Postman to send requests to our API:

2. Check the logs to ensure the Temporal workflow is being triggered and completed successfully.

6. Challenges and Considerations

While setting up this initial version of our order processing system, we encountered several challenges and considerations:

1. Database Schema Design : Designing a flexible yet efficient schema for orders is crucial. We kept it simple for now, but in a real-world scenario, we might need to consider additional tables for order items, customer information, etc.

2. Error Handling : Our current implementation has basic error handling. In a production system, we’d need more robust error handling and logging, especially for the Temporal workflows.

3. Configuration Management : We hardcoded configuration values for simplicity. In a real-world scenario, we’d use environment variables or a configuration management system.

4. Sicherheit: Unser aktuelles Setup beinhaltet keine Authentifizierung oder Autorisierung. In einem Produktionssystem müssten wir geeignete Sicherheitsmaßnahmen implementieren.

5. Skalierbarkeit: Während Temporal bei der Skalierbarkeit des Workflows hilft, müssen wir die Datenbankskalierbarkeit und die API-Leistung für ein System mit hohem Datenverkehr berücksichtigen.

6. Überwachung und Beobachtbarkeit: Wir haben noch keine Überwachungs- oder Beobachtbarkeitstools implementiert. In einem Produktionssystem wären diese für die Wartung und Fehlerbehebung der Anwendung von entscheidender Bedeutung.

7. Nächste Schritte und Vorschau auf Teil 2

In diesem ersten Teil unserer Serie haben wir den Grundstein für unser Auftragsabwicklungssystem gelegt. Wir verfügen über eine grundlegende CRUD-API, Datenbankintegration und einen einfachen zeitlichen Workflow.

Im nächsten Teil werden wir uns eingehender mit zeitlichen Arbeitsabläufen und Aktivitäten befassen. Wir werden Folgendes erkunden:

1. Implementierung einer komplexeren Auftragsabwicklungslogik
2. Umgang mit lang andauernden Arbeitsabläufen mit Temporal
3. Implementierung von Wiederholungslogik und Fehlerbehandlung in Workflows
4. Versionierungsworkflows für sichere Updates
5. Implementierung von Saga-Mustern für verteilte Transaktionen
6. Überwachung und Beobachtbarkeit für zeitliche Arbeitsabläufe

Wir werden außerdem damit beginnen, unsere API mit einer realistischeren Auftragsabwicklungslogik zu ergänzen und Muster für die Beibehaltung sauberen, wartbaren Codes zu untersuchen, wenn unser System immer komplexer wird.

Bleiben Sie gespannt auf Teil 2, in dem wir unser Auftragsabwicklungssystem auf die nächste Stufe bringen!

---

Brauchen Sie Hilfe?

Stehen Sie vor herausfordernden Problemen oder benötigen Sie eine externe Perspektive auf eine neue Idee oder ein neues Projekt? Ich kann helfen! Ganz gleich, ob Sie einen Technologie-Proof of Concept erstellen möchten, bevor Sie eine größere Investition tätigen, oder ob Sie Beratung bei schwierigen Themen benötigen, ich bin hier, um Ihnen zu helfen.

Angebotene Dienstleistungen:

• Problemlösung:Komplexe Probleme mit innovativen Lösungen angehen.
• Beratung: Bereitstellung fachkundiger Beratung und neuer Standpunkte zu Ihren Projekten.
• Proof of Concept: Entwicklung vorläufiger Modelle zum Testen und Validieren Ihrer Ideen.

Wenn Sie an einer Zusammenarbeit mit mir interessiert sind, wenden Sie sich bitte per E-Mail an hungaikevin@gmail.com.

Lassen Sie uns Ihre Herausforderungen in Chancen verwandeln!

Das obige ist der detaillierte Inhalt vonImplementierung eines Auftragsverarbeitungssystems: Teil Gründung der Stiftung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!