Aws transcribe AWS transcribe无法从链AwsCredentialsProviderChain中的任何提供程序加载凭据

我正在运行一个使用AWS转录流的java程序。我已经创建（从AWS控制台）并下载了AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY，然后设置了环境变量。 运行程序时，我收到错误消息：

无法从链AwsCredentialsProviderChain中的任何提供程序加载凭据

我不知道为什么，但在使用谷歌SDK进行语音识别时也发生了这个错误

下面是我试图运行的代码

public class TranscribeStreamingDemoApp {

    private static final Region REGION = Region.US_WEST_2;
    private static TranscribeStreamingAsyncClient client;

    public static void main(String args[]) throws URISyntaxException, ExecutionException, InterruptedException, LineUnavailableException {
      
        client = TranscribeStreamingAsyncClient.builder()
                .credentialsProvider(getCredentials())
                .region(REGION)
                .build();

        CompletableFuture<Void> result = client.startStreamTranscription(getRequest(16_000),
                new AudioStreamPublisher(getStreamFromMic()),
                getResponseHandler());

        result.get();
        client.close();
    }

    private static InputStream getStreamFromMic() throws LineUnavailableException {

        // Signed PCM AudioFormat with 16kHz, 16 bit sample size, mono
        int sampleRate = 16000;
        AudioFormat format = new AudioFormat(sampleRate, 16, 1, true, false);
        DataLine.Info info = new DataLine.Info(TargetDataLine.class, format);

        if (!AudioSystem.isLineSupported(info)) {
            System.out.println("Line not supported");
            System.exit(0);
        }

        TargetDataLine line = (TargetDataLine) AudioSystem.getLine(info);
        line.open(format);
        line.start();

        InputStream audioStream = new AudioInputStream(line);
        return audioStream;
    }

    private static AwsCredentialsProvider getCredentials() {
        return DefaultCredentialsProvider.create();
    }

    private static StartStreamTranscriptionRequest getRequest(Integer mediaSampleRateHertz) {
        return StartStreamTranscriptionRequest.builder()
                .languageCode(LanguageCode.FR_FR.toString())
                .mediaEncoding(MediaEncoding.PCM)
                .mediaSampleRateHertz(mediaSampleRateHertz)
                .build();
    }

    private static StartStreamTranscriptionResponseHandler getResponseHandler() {
        return StartStreamTranscriptionResponseHandler.builder()
                .onResponse(r -> {
                    System.out.println("Received Initial response");
                })
                .onError(e -> {
                    System.out.println(e.getMessage());
                    StringWriter sw = new StringWriter();
                    e.printStackTrace(new PrintWriter(sw));
                    System.out.println("Error Occurred: " + sw.toString());
                })
                .onComplete(() -> {
                    System.out.println("=== All records stream successfully ===");
                })
                .subscriber(event -> {
                    List<software.amazon.awssdk.services.transcribestreaming.model.Result> results = ((TranscriptEvent) event).transcript().results();
                    if (results.size() > 0) {
                        if (!results.get(0).alternatives().get(0).transcript().isEmpty()) {
                            System.out.println(results.get(0).alternatives().get(0).transcript());
                        }
                    }
                })
                .build();
    }

    private InputStream getStreamFromFile(String audioFileName) {
        try {
            File inputFile = new File(getClass().getClassLoader().getResource(audioFileName).getFile());
            InputStream audioStream = new FileInputStream(inputFile);
            return audioStream;
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    private static class AudioStreamPublisher implements Publisher<AudioStream> {

        private final InputStream inputStream;
        private static Subscription currentSubscription;

        private AudioStreamPublisher(InputStream inputStream) {
            this.inputStream = inputStream;
        }

        @Override
        public void subscribe(Subscriber<? super AudioStream> s) {

            if (this.currentSubscription == null) {
                this.currentSubscription = new SubscriptionImpl(s, inputStream);
            } else {
                this.currentSubscription.cancel();
                this.currentSubscription = new SubscriptionImpl(s, inputStream);
            }
            s.onSubscribe(currentSubscription);
        }
    }

    public static class SubscriptionImpl implements Subscription {

        private static final int CHUNK_SIZE_IN_BYTES = 1024 * 1;
        private final Subscriber<? super AudioStream> subscriber;
        private final InputStream inputStream;
        private ExecutorService executor = Executors.newFixedThreadPool(1);
        private AtomicLong demand = new AtomicLong(0);

        SubscriptionImpl(Subscriber<? super AudioStream> s, InputStream inputStream) {
            this.subscriber = s;
            this.inputStream = inputStream;
        }

        @Override
        public void request(long n) {
            if (n <= 0) {
                subscriber.onError(new IllegalArgumentException("Demand must be positive"));
            }

            demand.getAndAdd(n);

            executor.submit(() -> {
                try {
                    do {
                        ByteBuffer audioBuffer = getNextEvent();
                        if (audioBuffer.remaining() > 0) {
                            AudioEvent audioEvent = audioEventFromBuffer(audioBuffer);
                            subscriber.onNext(audioEvent);
                        } else {
                            subscriber.onComplete();
                            break;
                        }
                    } while (demand.decrementAndGet() > 0);
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            });
        }

        @Override
        public void cancel() {
            executor.shutdown();
        }

        private ByteBuffer getNextEvent() {
            ByteBuffer audioBuffer = null;
            byte[] audioBytes = new byte[CHUNK_SIZE_IN_BYTES];

            int len = 0;
            try {
                len = inputStream.read(audioBytes);

                if (len <= 0) {
                    audioBuffer = ByteBuffer.allocate(0);
                } else {
                    audioBuffer = ByteBuffer.wrap(audioBytes, 0, len);
                }
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }

            return audioBuffer;
        }

        private AudioEvent audioEventFromBuffer(ByteBuffer bb) {
            return AudioEvent.builder()
                    .audioChunk(SdkBytes.fromByteBuffer(bb))
                    .build();
        }
    }
}

公共类转录StreamingDemoApp{
私有静态最终区域区域=Region.US_WEST_2；
私有静态转录流同步客户端；
publicstaticvoidmain（字符串args[]）抛出URISyntaxException、ExecutionException、InterruptedException、LineUnavailableException{
client=转录StreamingAsyncClient.builder（）
.credentialsProvider（getCredentials（））
.地区（地区）
.build（）；
CompletableFuture result=client.startStreamTranscription（getRequest（16_000）），
新的AudioStreamPublisher（getStreamFromMic（）），
getResponseHandler（））；
result.get（）；
client.close（）；
}
私有静态InputStream getStreamFromMic（）引发LineUnavailableException{
//带符号的PCM音频格式，16kHz，16位样本大小，单声道
int-sampleRate=16000；
AudioFormat格式=新的AudioFormat（sampleRate，16，1，true，false）；
DataLine.Info=newdataline.Info（TargetDataLine.class，格式）；
如果（！AudioSystem.isLineSupported（信息））{
System.out.println（“不支持行”）；
系统出口（0）；
}
TargetDataLine line=（TargetDataLine）AudioSystem.getLine（info）；
行。打开（格式）；
line.start（）；
InputStream audioStream=新的AudioInputStream（行）；
返回音频流；
}
专用静态AwsCredentialsProvider getCredentials（）{
返回DefaultCredentialsProvider.create（）；
}
私有静态StartStreamTranscriptionRequest getRequest（整数MediaSamplerAthertz）{
return StartStreamTranscriptionRequest.builder（）
.languageCode（languageCode.FR\u FR.toString（））
.mediaEncoding（mediaEncoding.PCM）
.MediaSamplerAthertz（MediaSamplerAthertz）
.build（）；
}
私有静态StartStreamTranscriptionResponseHandler getResponseHandler（）{
return StartStreamTranscriptionResponseHandler.builder（）
.onResponse（r->{
System.out.println（“收到的初始响应”）；
})
.onError（e->{
System.out.println（e.getMessage（））；
StringWriter sw=新的StringWriter（）；
e、 printStackTrace（新PrintWriter（sw））；
System.out.println（“发生错误：+sw.toString（））；
})
.onComplete（（）->{
System.out.println（“==所有记录流成功==”；
})
.订户（事件->{
列出结果=（（转录事件）事件）.transcript（）.results（）；
如果（results.size（）>0）{
如果（！results.get（0.Alternations（）.get（0.transcript（）.isEmpty（））{
System.out.println（results.get（0.alternations（）.get（0.transcript（））；
}
}
})
.build（）；
}
私有InputStream getStreamFromFile（字符串音频文件名）{
试一试{
File inputFile=新文件（getClass（）.getClassLoader（）.getResource（audioFileName.getFile（））；
InputStream audioStream=新文件InputStream（inputFile）；
返回音频流；
}catch（filenotfounde异常）{
抛出新的运行时异常（e）；
}
}
私有静态类AudioStreamPublisher实现了Publisher{
私有最终输入流InputStream；
私有静态订阅；
私有AudioStreamPublisher（InputStream InputStream）{
this.inputStream=inputStream；
}
@凌驾
public void subscribe（Subscriber最后，我解决了这个问题，文档规定：
按以下顺序查找凭据的AWS凭据提供程序链：
1.Java系统属性-aws.accessKeyId和aws.secretAccessKey
2.环境变量-AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY
3.所有aws SDK和aws CLI共享的默认位置（~/.aws/credentials）处的凭据配置文件文件

因为通过环境变量设置不起作用，所以我选择使用Java系统属性设置凭据，它可以工作！
文件编号：

 System.setProperty("aws.accessKeyId", "**************");
    System.setProperty("aws.secretAccessKey", "**************");