jdeps --print-module-deps target/myapp.jar
Вывод: java.base,java.logging,java.xml.  
   

   RUN jlink \
       --add-modules java.base,java.logging,java.xml \
       --output /jlinked \
       --strip-debug \ — удаление отладочной информации.  
       --compress 2 \ — максимальное сжатие (уменьшает размер на 30%).  
       --no-header-files \
       --no-man-pages
   

FROM gcr.io/distroless/java17-debian11
COPY --from=builder /app/target/myapp.jar /app.jar
ENTRYPOINT ["/app.jar"]

# Создаем пользователя с UID 1001
RUN adduser --uid 1001 --disabled-password --gecos "" appuser
USER 1001
COPY --chown=1001:1001 target/myapp.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

    # docker-compose.yml
    app:
      cap_add:
        - NET_BIND_SERVICE
    

  RUN mkdir /app/tmp && chown 1001:1001 /app/tmp
  ENV JAVA_OPTS="-Djava.io.tmpdir=/app/tmp"

   # Stage 1: Сборка
   FROM maven:3.8.6 AS builder
   COPY . .
   RUN mvn package

   # Stage 2: Финальный образ
   FROM openjdk:17-jre-slim
   COPY --from=builder target/myapp.jar /app.jar
   

   RUN apt-get update && \
       apt-get install -y curl && \
       rm -rf /var/lib/apt/lists/*
   

   RUN rm -rf $JAVA_HOME/jmods/java.corba.jmod
   

  docker run -m 512m --cpus=1.5 myapp
  

  environment:
    JAVA_TOOL_OPTIONS: "-XX:MaxRAMPercentage=75.0" //указывает JVM использовать 75% от лимита cgroups.

docker exec myapp cat /sys/fs/cgroup/memory.max
docker exec myapp cat /sys/fs/cgroup/cpu.max

   # application.properties
   spring.task.execution.pool.core-size=4
   spring.task.execution.pool.max-size=8
   

   int availableCpus = (int) Math.min(
       Runtime.getRuntime().availableProcessors(), 
       Double.parseDouble(System.getenv("CPU_LIMIT"))
   );
   ExecutorService executor = Executors.newFixedThreadPool(availableCpus * 2);
   

public static int getContainerCpuLimit() {
  try (BufferedReader reader = new BufferedReader(
      new FileReader("/sys/fs/cgroup/cpu.max"))) {
    String line = reader.readLine();
    String[] parts = line.split(" ");
    long quota = Long.parseLong(parts[0]);
    long period = Long.parseLong(parts[1]);
    return (int) (quota / period); // Например, 1.5 → 1
  }
}

environment:
  JAVA_TOOL_OPTIONS: >-
    -XX:+UseContainerSupport
    -XX:MaxRAMPercentage=75.0
    -XX:+UseZGC
    -Djava.security.egd=file:/dev/./urandom

docker exec myapp jstat -gcutil 1 1000

# Стэк-трейс
docker exec myapp jstack 1 > thread_dump.txt

# Мониторинг GC
docker exec myapp jstat -gcutil 1 1000

# Heap-дамп
docker exec myapp jcmd 1 GC.heap_dump /tmp/heap.hprof

    debug-tools:
      image: openjdk:17
      volumes:
        - /var/run/docker.sock:/var/run/docker.sock
      command: ["jstack", "myapp"]
    

    RUN jlink \
        --add-modules jdk.jfr,jdk.management \
        --output /jlinked
    

environment:
  JAVA_TOOL_OPTIONS: >-
    -Dcom.sun.management.jmxremote.port=9090
    -Dcom.sun.management.jmxremote.rmi.port=9090
    -Dcom.sun.management.jmxremote.ssl=false
    -Dcom.sun.management.jmxremote.authenticate=false
    -Djava.rmi.server.hostname=myapp
ports:
  - "9090:9090"

  -Dcom.sun.management.jmxremote.rmi.port=9090
  

# Запуск записи
docker exec myapp jcmd 1 JFR.start name=recording duration=60s filename=/tmp/recording.jfr

# Экспорт метрик в Prometheus
RUN jcmd 1 JFR.configure stackdepth=128

   <dependency>
     <groupId>io.micrometer</groupId>
     <artifactId>micrometer-registry-prometheus</artifactId>
   </dependency>
   

   management.endpoints.web.exposure.include=prometheus
   

   services:
     app:
       ports:
         - "8080:8080"
     prometheus:
       image: prom/prometheus
       volumes:
         - ./prometheus.yml:/etc/prometheus/prometheus.yml
       ports:
         - "9090:9090"
   

   scrape_configs:
     - job_name: 'java'
       metrics_path: '/actuator/prometheus'
       static_configs:
         - targets: ['app:8080']
   

public class Task100925 {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = a;
        b[0] = 10;
        System.out.println(a[0]);
    }
}

public class Circle {
    private final double PI = 3.14159;  // Константа
    private final double radius;        // Поле, инициализируется в конструкторе

    public Circle(double radius) {
        this.radius = radius;  // Инициализация final
    }

    public double getArea() {
        final double area = PI * radius * radius;  // Локальная final переменная
        // area = 10; // Ошибка: нельзя изменить
        return area;
    }
}

public class Animal {
    public final void eat() {
        System.out.println("Животное ест.");
    }
}

public class Dog extends Animal {
    // Ошибка, если попытаться:
    // @Override
    // public void eat() { System.out.println("Собака ест кости."); }
}

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

// Ошибка:
// public class ExtendedPoint extends ImmutablePoint {}

public class Task110925 {
    public static void main(String[] args) {
        final int x = 10;
        final int y = getValue();
        
        System.out.println(x + y);
    }
    
    static int getValue() {
        return 20;
    }
}

# Stage 1: Сборка с Maven
FROM maven:3.8.6-openjdk-17 AS builder
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline -B  # Загружаем зависимости без исходников
COPY src ./src
RUN mvn package -DskipTests

# Stage 2: Минимальная JVM через jlink
FROM openjdk:17 AS jlink
ARG TARGETARCH
RUN jlink \
    --add-modules java.base,java.logging,java.xml,java.management,java.naming \
    --output /jlinked \
    --strip-debug \
    --compress 2 \
    --no-header-files \
    --no-man-pages

# Stage 3: Distroless-образ
FROM gcr.io/distroless/java17-debian11
COPY --from=jlink /jlinked /jlinked
COPY --from=builder /app/target/myapp.jar /app.jar

# Создаем non-root пользователя
RUN addgroup --gid 1001 appgroup && \
    adduser --uid 1001 --gid 1001 --disabled-password --gecos "" appuser
USER 1001

# Настройка JVM под контейнеры
ENV JAVA_OPTS="\
  -XX:+UseContainerSupport \
  -XX:MaxRAMPercentage=75.0 \
  -XX:+UseZGC \
  -Djava.security.egd=file:/dev/./urandom"
ENTRYPOINT ["/jlinked/bin/java", "${JAVA_OPTS}", "-jar", "/app.jar"]

  docker cp myapp:/tmp/heap.hprof .  # Если heap_dump настроен в JAVA_TOOL_OPTIONS
  

  docker exec myapp cat /sys/fs/cgroup/memory.max

version: '3.8'
services:
  app:
    image: myapp:latest
    ports:
      - "8080:8080"
    environment:
      DB_URL: jdbc:postgresql://db:5432/mydb
      DB_PASSWORD: ${DB_PASSWORD}
      KAFKA_BOOTSTRAP_SERVERS: kafka:9092
    depends_on:
      db:
        condition: service_healthy
      kafka:
        condition: service_healthy
    networks:
      - app_net
    deploy:
      resources:
        limits:
          cpus: '1.5'
          memory: 512M

  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - pg_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 5s
      retries: 10
    networks:
      - app_net
    deploy:
      resources:
        limits:
          memory: 256M

  kafka:
    image: bitnami/kafka:3.5.1
    container_name: kafka
    ports:
      - "9092:9092"
    environment:
      KAFKA_CFG_NODE_ID: 0
      KAFKA_CFG_PROCESS_ROLES: "broker,controller"
      KAFKA_CFG_LISTENERS: "PLAINTEXT://:9092,CONTROLLER://:9093"
      KAFKA_CFG_ADVERTISED_LISTENERS: "PLAINTEXT://kafka:9092"
      KAFKA_CFG_LISTENER_SECURITY_PROTOCOL_MAP: "PLAINTEXT:PLAINTEXT,CONTROLLER:PLAINTEXT"
      KAFKA_CFG_CONTROLLER_LISTENER_NAMES: "CONTROLLER"
      KAFKA_CFG_INTER_BROKER_LISTENER_NAME: "PLAINTEXT"
    volumes:
      - kafka_data:/bitnami/kafka
    healthcheck:
      test: ["CMD", "kafka-broker-api-versions.sh", "--bootstrap-server", "localhost:9092"]
      interval: 10s
      timeout: 10s
      retries: 20
    networks:
      - app_net
    deploy:
      resources:
        limits:
          memory: 512M

volumes:
  pg_data:
    driver: local
  kafka_data:
    driver: local

networks:
  app_net:
    driver: bridge

name: Build and Push Docker Image
on:
  push:
    branches: [ main ]
    tags: [ 'v*' ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up QEMU for multi-arch
        uses: docker/setup-qemu-action@v2

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v2

      - name: Login to DockerHub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Cache Docker layers
        uses: actions/cache@v3
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ github.sha }}
          restore-keys: ${{ runner.os }}-buildx-

      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: myapp:latest,myapp:${{ github.sha }}
          cache-from: type=local,src=/tmp/.buildx-cache
          cache-to: type=local,dest=/tmp/.buildx-cache-new
          build-args: |
            BUILDKIT_INLINE_CACHE=1

- name: Scan with Trivy
  uses: aquasecurity/trivy-action@master
  with:
    image-ref: 'myapp:${{ github.sha }}'
    format: 'table'
    exit-code: '1'
    ignore-unfixed: true
    severity: 'CRITICAL,HIGH'

- name: Snyk Container scan
  uses: snyk/actions/container@master
  env:
    SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}
  with:
    image: myapp:${{ github.sha }}
    args: --severity-threshold=high --fail-on=all

     {
       "rules": [
         {
           "rulePriority": 1,
           "description": "Удалять образы старше 30 дней",
           "selection": {
             "tagStatus": "untagged",
             "countType": "sinceImagePushed",
             "countUnit": "days",
             "countNumber": 30
           },
           "action": { "type": "expire" }
         }
       ]
     }
     

├── docker-compose.yml        # Базовая конфигурация
├── docker-compose.dev.yml    # Dev-окружение
├── docker-compose.prod.yml   # Production
└── .env

services:
  app:
    environment:
      SPRING_PROFILES_ACTIVE: prod
      JAVA_TOOL_OPTIONS: >-
        -XX:MaxRAMPercentage=75.0
        -XX:+UseZGC
    deploy:
      replicas: 3
      update_config:
        parallelism: 1
        order: start-first
    networks:
      - monitoring_net

  db:
    environment:
      POSTGRES_PASSWORD: ${PROD_DB_PASSWORD}
    volumes:
      - /mnt/prod/pg_data:/var/lib/postgresql/data

docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

helm create myapp
   

   app:
     replicaCount: 3
     image:
       repository: myapp
       tag: "v1.0.0"
     resources:
       limits:
         memory: 512Mi
         cpu: "1.5"
   

   # kafka.yaml
   apiVersion: kafka.strimzi.io/v1beta2
   kind: Kafka
   spec:
     kafka:
       version: 3.5.0
       replicas: 3
       listeners:
         - name: plain
           port: 9092
           type: internal
           tls: false
   

public class Task120925 {
    public static void main(String[] args) {
        double a = 0.1;
        double b = 0.2;
        double c = 0.3;
        
        System.out.println(a + b == c);
    }
}