출처1 : https://github.com/shred/acme4j
출처2 : https://shredzone.org/maven/acme4j/index.html
출처3 : http://tutorials.jenkov.com/acme4j/index.html

<!-- https://mvnrepository.com/artifact/org.shredzone.acme4j/acme4j-client -->
<dependency>
    <groupId>org.shredzone.acme4j</groupId>
    <artifactId>acme4j-client</artifactId>
    <version>2.12</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.shredzone.acme4j/acme4j-utils -->
<dependency>
    <groupId>org.shredzone.acme4j</groupId>
    <artifactId>acme4j-utils</artifactId>
    <version>2.12</version>
</dependency>

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FilenameUtils;
import org.shredzone.acme4j.*;
import org.shredzone.acme4j.challenge.Http01Challenge;
import org.shredzone.acme4j.exception.AcmeException;
import org.shredzone.acme4j.util.CSRBuilder;
import org.shredzone.acme4j.util.KeyPairUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.KeyPair;

@Slf4j
@RequiredArgsConstructor
@Component
public class Acme4jHelper {

    // https://github.com/shred/acme4j
    // https://shredzone.org/maven/acme4j/index.html
    // http://tutorials.jenkov.com/acme4j/index.html

    @Value("${letsencrypt.work.dir}")
    private String _LETS_WORK_DIR;

    @Value("${letsencrypt.url}")
    private String LETS_URL;

    @Autowired
    private S3Service s3Service;

    @Value("${letsencrypt.bucket}")
    private String BUCKET_NAME;

    @Value("${letsencrypt.retry}")
    private int MAX_RETRY_COUNT;


    @PostConstruct
    private void initStatic() {
        WORK_DIR = _LETS_WORK_DIR + File.separator + "letsencrypt";
    }

    private static String WORK_DIR;
    private static String Http01Challenge_FORMAT = """
            \ncat <<EOF > {}
            {}
            EOF
            """;


    private static final String CHALLENGE_FILE_FORMAT = "cert/_letsencrypt/.well-known/acme-challenge/%s";

    private void saveChallenge(String token, String content) {
        s3Service.uploadByStringContent(String.format(CHALLENGE_FILE_FORMAT, token), content);
        log.warn("@@@@@@ 파일은 올렸으나 퍼미션이 없어서 사용할 수 없다.");
    }

    private void deleteChallenge(String token) {
        s3Service.delete(String.format(CHALLENGE_FILE_FORMAT, token));
    }


    /**
     * let's encrypt 에 인증서를 요청한다.
     * nginx의 도메인 root 폴더를 조작할 수 있어야 한다.
     * Http Challenge 사용하여 도메인 인증을 받는다.
     * 여러 도메인을 받을 수 있지만, 우선은 도메인은 하나만 받고 www 형식을 추가하는 식으로 진행한다.
     *
     * @param domains
     * @throws AcmeException
     * @throws InterruptedException
     * @throws IOException
     */
    public CertFileInfo getCertificateByLetsEncrypt(String... domains) throws AcmeException, InterruptedException, IOException {

        if (domains.length < 1) {
            throw new NullPointerException("하나 이상의 도메인을 요청하여야 합니다.");
        }

        CertFileInfo info = new CertFileInfo(WORK_DIR, domains[0]);

        // 계정용 keypair 생성 및 account 객체 생성
        KeyPair accountKeypair = getKeypair(info.getAccountKeypairFilePath());
        Account account = getAccount(accountKeypair, info.getAccountUrlFilePath());

        // 도메인 주문 생성 및 도메인 검증
        Order order = account.newOrder()
                .domains(info.getDomains())
                .create();

        for (Authorization auth : order.getAuthorizations()) {
            if (auth.getStatus() != Status.VALID) {
                processAuth(auth);
            }
        }

        // 인증서 요청서 작성
        createCertificateSigningRequest(order, info.getDomainPrivateKeyFilePath(), info.getDomainCertRequestFilePath()
                , info.getDomains().stream().toArray(String[]::new));

        // 인증서 요청 및 다운로드
        downloadCertificate(order, info.getDomainCertFilePath());

        return info;
    }

    /**
     * 인증서를 다운 받는다.
     *
     * @param order
     * @param domainCertFilePath
     * @throws InterruptedException
     * @throws AcmeException
     * @throws IOException
     */
    private void downloadCertificate(Order order, String domainCertFilePath) throws InterruptedException, AcmeException, IOException {

        for (int i = 0; i < MAX_RETRY_COUNT; i++) {
            if (order.getStatus() != Status.VALID) {
                Thread.sleep(3000L);
                order.update();
            }
        }

        if (order.getStatus() != Status.VALID) {
            throw new AcmeException("do not work downloadCertificate, timeout");
        }


        Certificate cert = order.getCertificate();

        // 이거시 도메인 퍼블릭키
        try (FileWriter fw = new FileWriter(domainCertFilePath)) {
            cert.writeCertificate(fw);
        }
    }

    /**
     * 인증요청서를 작성해야 한다.
     *
     * @param order
     * @param domainPrivateKeyFilePath
     * @param domainCertRequestFilePath
     * @param domains
     * @throws IOException
     * @throws AcmeException
     */
    private void createCertificateSigningRequest(Order order, String domainPrivateKeyFilePath, String domainCertRequestFilePath, String... domains) throws IOException, AcmeException {
        KeyPair domainKeyPair = KeyPairUtils.createKeyPair(2048);

        try (FileWriter fw = new FileWriter(domainPrivateKeyFilePath)) {
            KeyPairUtils.writeKeyPair(domainKeyPair, fw);
        }

        CSRBuilder csrb = new CSRBuilder();
        for (String domain : domains) {
            csrb.addDomain(domain);
        }
        csrb.setOrganization("motolies");
        csrb.sign(domainKeyPair);
        byte[] csr = csrb.getEncoded();

        csrb.write(new FileWriter(domainCertRequestFilePath));

        order.execute(csr);
    }


    /**
     * let's encrypt 에 도메인 owner 인증을 받는다.
     *
     * @param auth
     * @throws AcmeException
     * @throws InterruptedException
     */
    private void processAuth(Authorization auth) throws AcmeException, InterruptedException {
        Http01Challenge challenge = auth.findChallenge(Http01Challenge.class);
        String domain = auth.getIdentifier().getDomain();
        String token = challenge.getToken();
        String content = challenge.getAuthorization();

        log.warn("@@@@@ 이 시점에 S3에 파일을 밀어 넣는다.");
        log.warn("http01Challenge Url  >>>  http://{}/.well-known/acme-challenge/{}", domain, token);
        log.warn(Http01Challenge_FORMAT, token, content);

        saveChallenge(token, content);
        Thread.sleep(1000L);

        challenge.trigger();

        for (int i = 0; i < MAX_RETRY_COUNT; i++) {
            if (auth.getStatus() != Status.VALID) {
                Thread.sleep(3000L);
                auth.update();
            }
        }

        deleteChallenge(token);

        if (auth.getStatus() != Status.VALID) {
            throw new AcmeException("do not work processAuth(challenge), timeout");
        }

    }

    /**
     * let's encrypt에 로그인한 후 account 객체를 반환한다.
     *
     * @param accountKeypair
     * @param accountUrlFilePath
     * @return
     * @throws AcmeException
     * @throws IOException
     */
    private Account getAccount(KeyPair accountKeypair, String accountUrlFilePath) throws AcmeException, IOException {
        // keypair하고 loginUrl이 있어야 로그인 할 수 있다.
        Session session = new Session(LETS_URL);
        Account account = new AccountBuilder()
                //.onlyExisting()
                .useKeyPair(accountKeypair)
                .agreeToTermsOfService()
                .create(session);

        URL accountLocationUrl = account.getLocation();
        try (FileWriter fileWriter = new FileWriter(accountUrlFilePath)) {
            fileWriter.write(accountLocationUrl.toString());
        }
        return account;
    }


    /**
     * let's encrypt에 로그인하기위한 keypair를 생성/로드 한다.
     *
     * @param keyPairFilePath
     * @return
     * @throws IOException
     */
    private KeyPair getKeypair(String keyPairFilePath) throws IOException {

        KeyPair accountKeyPair;
        File keyPairFile = new File(keyPairFilePath);

        if (!keyPairFile.exists()) {
            // 파일인 경우 아래와 같이 path를 가져올 수 있다.
            String path = FilenameUtils.getFullPathNoEndSeparator(keyPairFile.getAbsolutePath());
            createDirectories(path);

            // Write key to disk, so it can be reused another time.
            accountKeyPair = KeyPairUtils.createKeyPair(2048);
            try (FileWriter fw = new FileWriter(keyPairFile)) {
                KeyPairUtils.writeKeyPair(accountKeyPair, fw);
            }
        } else {
            accountKeyPair = KeyPairUtils.readKeyPair(new FileReader(keyPairFilePath));
        }
        return accountKeyPair;
    }

    private static Path createDirectories(String folderPath) throws IOException {
        Path path = Paths.get(folderPath);
        return Files.createDirectories(path);
    }


}

[Java] acme4j 사용하여 Let's Encrypt 인증서 획득하기