当前位置:

首页 > 编程开发 > Java如何与Ansible自动化运维平台对接?

Java如何与Ansible自动化运维平台对接?

Java对接ansible自动运维化平台实现文件采集分发此次对接主要为以下两个功能:文件采集(对文件进行批量操作,包括批量从多台主机中采集共性文件如日志文件)文件分发(对文件进行批量操作,包括批量从多台主机中分发共性文件如日志文件)场景说明及ansibleyum安装因ansible没有Windows的安装包,所以为了方便测试,搭建了一套Linux环境进行后续工作。此次采用yum方式安装,在采用yum方式安装Ansible,首先安装EPEL源。yuminstall-yhttp://dl.fedoraproj

本文目录

    Java对接ansible自动运维化平台实现文件采集分发

    此次对接主要为以下两个功能:

    • 文件采集(对文件进行批量操作,包括批量从多台主机中采集共性文件如日志文件)

    • 文件分发(对文件进行批量操作,包括批量从多台主机中分发共性文件如日志文件)

    场景说明及ansible yum安装

    因ansible没有Windows的安装包,所以为了方便测试,搭建了一套Linux环境进行后续工作。

    此次采用yum方式安装,在采用yum方式安装Ansible,首先安装EPEL源。

    yum install -y http://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm

    查看EPEL源中的Ansible版本

    yum info ansible

    直接安装此版本,如果有其他要求,请调整源,安装其他ansible版本

    yum install -y ansible

    安装完成之后,查看ansible版本信息

    ansible --version

    配置Ansible服务器清单

    清单文件/etc/ansible/hosts,在此文件中编写节点主机的对应IP地址和端口

    Java如何与Ansible自动化运维平台对接?

    我这里只是做一个演示,其中IP后面可以添加节点真实的SSH的端口,在定义的内容上面有一个[]列表,里面的内容为自定义内容,方面为了操作绑定的节点主机,我习惯称之为分组列表

    简单的认证一下,Ping一下添加的主机

    Java如何与Ansible自动化运维平台对接?

    成功安装ansible !!

    Java代码实现文件分发

    顾名思义,文件分发就是把本机的文件分发到多个主机。

    这时候就需要 Apache POI(大家可以去导入对应的包)来创建本机的文件了(ansible Host配置文件也通过POI创建)

    POI创建文件工具类

    package com.tiduyun.cmp.operation.utils;
    
    import com.tiduyun.cmp.common.model.operation.HostInfo;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.lang.StringUtils;
    import org.springframework.stereotype.Component;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author huyuan@tiduyun.com ansible创建文件
     */
    @Slf4j
    @Component
    public class AnsibleCreateFileUtils {
        private final static String filename = "hosts";
    
        public static String passWordConnect(List hostInfo, String hostGroup , String directory) throws IOException{
            /** 在本地新建一个文件夹 里面创建一个文件 向里面写入内容 */
    
    
            // 创建文件夹对象 创建文件对象
            File folder = new File(directory);
            // 如果文件夹不存在 就创建一个空的文件夹
            if (!folder.exists()) {
                log.info("创建了文件夹{}" , folder);
                folder.mkdirs();
            }
            File file = new File(directory, filename);
            // 如果文件不存在 就创建一个空的文件
            if (!file.exists()) {
                try {
                    log.info("创建了文件{}" , file);
                    file.createNewFile();
                } catch (IOException e) {
                    log.error("error data{}" , e);
                }
            }
            // 写入数据
            // 创建文件字节输出流
            FileOutputStream fos = new FileOutputStream(file);
            try {
                List list = new ArrayList<>();
                for (HostInfo data : hostInfo) {
                    // 开始写
                    String string = data.getHost() + " ansible_ssh_pass=" + data.getPasswd() + " ansible_ssh_user="
                        + data.getAccount() + " ansible_ssh_port=" + data.getPort();
                    list.add(string);
                }
                String splicingData = StringUtils.join(list, "\n");
                String str = "[" + hostGroup + "]" + "\n" + splicingData;
                byte[] bytes = str.getBytes();
                // 将byte数组中的所有数据全部写入
                fos.write(bytes);
                fos.flush();
                log.info("文件内容{}" , str);
                // 删除文件
                // deleteFile(file);
                // 关闭流
    
            } catch (IOException e) {
                log.error("error data{}" , e);
                throw e;
            }finally {
                if (fos != null) {
                    fos.close();
                }
            }
            return directory;
        }
    
        public static void deleteFile(File file) {
            if (file.exists()) {// 判断路径是否存在
                if (file.isFile()) {// boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。
                    file.delete();
                } else {// 不是文件,对于文件夹的操作
                        // 保存 路径D:/1/新建文件夹2 下的所有的文件和文件夹到listFiles数组中
                    File[] listFiles = file.listFiles();// listFiles方法:返回file路径下所有文件和文件夹的绝对路径
                    for (File file2 : listFiles) {
                        /*
                         * 递归作用:由外到内先一层一层删除里面的文件 再从最内层 反过来删除文件夹
                         *    注意:此时的文件夹在上一步的操作之后,里面的文件内容已全部删除
                         *         所以每一层的文件夹都是空的  ==》最后就可以直接删除了
                         */
                        deleteFile(file2);
                    }
                }
                file.delete();
            } else {
                log.error("该file路径不存在!!");
            }
    
        }
    }

    创建主机组配置文件

    注:ansible分为两种连接方式,这里采用的是密钥连接,生成的文件已拼接密钥!!!后续的采集与分发都要用到这个。(如有不懂的小伙伴,可以去查找一下ansible的连接方式)

        @Override
        public void ansibleCreateHost(HostInfo hostInfo, String Key) {
            ParamCheckUtils.notNull(hostInfo, "hostInfo");
    
            List HostIp = Arrays.asList(hostInfo);
            for (HostInfo data : HostIp) {
                String ansiblePassWd = data.getPasswd();
                String PassWd = hostInfoService.decode(ansiblePassWd);
                data.setPasswd(PassWd);
            }
            try {
                AnsibleCreateFileUtils.passWordConnect(HostIp, ansibleConfigurationItemVo.getHostGroup(),
                    ansibleConfigurationItemVo.getDirectory());
            } catch (IOException e) {
                log.error("Failed to create host configuration{}", e);
            }
        }

    实现文件分发

    主机配置文件已经配置好,接下来就是执行ansible对应的命令,通过Java拼接ansible命令。

    执行命令工具类


    package com.tiduyun.cmp.operation.utils;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.nio.charset.Charset;
    
    import static cn.hutool.db.DbUtil.close;
    
    /**
     * @author huyuan@tiduyun.com ansible执行命令工具类
     * upload 上传文件
     * createRemoteDirectory  创建远程目录
     */
    @Slf4j
    public class AnsibleExecuteTheOrderUtils {
    
        private final static String commandBin = "/bin/sh";
    
        private final static String commandC = "-c";
    
    
        /**
         *  创建远程目录
         */
        public static void createRemoteDirectory(String hostGroup, String remotePath, String directory) throws IOException {
            Runtime run = Runtime.getRuntime();
            String[] cmds = new String[3];
            cmds[0] = commandBin;
            cmds[1] = commandC;
            cmds[2] =
                    "ansible " + hostGroup + " -m command -a " + "\"mkdir " + remotePath + "\"" + " -i " + directory + "/hosts";
    
            // 执行CMD命令
            Process p = run.exec(cmds);
            log.info("ansible远程执行命令为{}", cmds[2]);
    
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
            try {
                String lineMes;
                while ((lineMes = br.readLine()) != null)
                    log.info(lineMes);// 打印输出信息
                try {
                    // 检查命令是否执行失败。
                    if (p.waitFor() != 0) {
                        if (p.exitValue() == 1)// 0表示正常结束,1:非正常结束
                            log.error("命令执行失败");
                    }
                } catch (InterruptedException e) {
                    log.error("error data{}", e);
                }
            } catch (IOException e) {
                log.error("fail to carry out command{}", e);
                throw e;
            } finally {
                if (br != null) {
                    br.close();
                }
            }
    
        }
    
        /**
         *  文件分发
         */
        public static void upload(String hostGroup, String localPath, String remotePath, String directory)
            throws IOException {
            Runtime run = Runtime.getRuntime();
            String[] cmds = new String[3];
            cmds[0] = commandBin;
            cmds[1] = commandC;
            cmds[2] = "ansible " + hostGroup + " -m copy -a " + "\"src=" + localPath + " dest=" + remotePath + "\"" + " -i "
                + directory + "/hosts";
            // 执行CMD命令
            Process p = run.exec(cmds);
            log.info("ansible命令为{}", cmds[2]);
    
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
            try {
                String lineMes;
                while ((lineMes = br.readLine()) != null)
                    log.info("ansible输出信息为 :" + lineMes);// 打印输出信息
                try {
                    // 检查命令是否执行失败。
                    if (p.waitFor() != 0) {
                        if (p.exitValue() == 1)// 0表示正常结束,1:非正常结束
                            log.error("命令执行失败");
                    }
                } catch (InterruptedException e) {
                    log.error("error data{}", e);
                }
            } catch (IOException e) {
                log.error("fail to carry out command{}", e);
                throw e;
            } finally {
                if (br != null) {
                    br.close();
                }
            }
    
        }
    
        /**
         *  文件采集
         */
        public static void fileCollection(String hostGroup, String remotePath, String localPath , String directory) throws IOException {
            Runtime run = Runtime.getRuntime();
            String[] cmds = new String[3];
            cmds[0] = commandBin;
            cmds[1] = commandC;
            cmds[2] = "ansible " + hostGroup + " -m fetch -a " + "\"src=" + remotePath + " dest=" + localPath + " force=yes backup=yes\"" + " -i "
                    + directory + "/hosts";
    
            // 执行CMD命令
            Process p = run.exec(cmds);
            log.info("ansible远程采集文件命令为{}", cmds[2]);
    
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
            try {
                String lineMes;
                while ((lineMes = br.readLine()) != null)
                    log.info(lineMes);// 打印输出信息
                try {
                    // 检查命令是否执行失败。
                    if (p.waitFor() != 0) {
                        if (p.exitValue() == 1)// 0表示正常结束,1:非正常结束
                            log.error("命令执行失败");
                    }
                } catch (InterruptedException e) {
                    log.error("error data{}", e);
                }
            } catch (IOException e) {
                log.error("fail to carry out command{}", e);
                throw e;
            } finally {
                if (br != null) {
                    br.close();
                }
            }
    
        }
    
        public static void ExecuteTheOrder(String command) throws IOException {
            log.info("start execute cmd {}", command);
    
            String[] cmd = new String[] {"/bin/bash", "-c", command};
            Runtime run = Runtime.getRuntime();
            Process p = run.exec(cmd); // 执行CMD命令
    
            BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), Charset.forName("UTF-8")));
            try {
                String lineMes;
                while ((lineMes = br.readLine()) != null)
                    log.info("输出信息为 {}", lineMes);// 打印输出信息
                try {
                    // 检查命令是否执行失败。
                    if (p.waitFor() != 0) {
                        if (p.exitValue() == 1)// 0表示正常结束,1:非正常结束
                            log.error("命令执行失败");
                    }
                } catch (InterruptedException e) {
                    log.error("error data{}", e);
                }
    
            } catch (IOException e) {
                log.error("fail to carry out command{}", e);
                throw e;
            } finally {
                if (br != null) {
                    br.close();
                }
            }
        }
    
        public static void disconnect() {
            try {
                close();
            } catch (Exception ex) {
                // Ignore because disconnection is quietly
            }
        }
    
        // public void execute(String command) throws Exception {
        // log.info("start execute cmd {}", command);
        // try (Session session = sshClient.startSession()) {
        // Session.Command exec = session.exec(command);
        //
        // Integer readLineCount = 0;
        // InputStream in = exec.getInputStream();
        // log.info(IOUtils.readFully(in).toString());
        // String errorMessage = IOUtils.readFully(exec.getErrorStream(), LoggerFactory.DEFAULT).toString();
        // log.info(errorMessage);
        // if (exec.getExitStatus() != null && exec.getExitStatus() != 0) {
        // throw new RuntimeException(
        // "exec " + command + " error,error message is " + errorMessage + ",error code " + exec.getExitStatus());
        // }
        // log.info("exec result code {}", exec.getExitStatus());
        //
        // }
        //
        // }
    }

    接下来就是调用

    package com.tiduyun.cmp.operation.service.impl;
    
    import cn.hutool.core.util.RandomUtil;
    import cn.hutool.core.util.StrUtil;
    import com.tiduyun.cmp.common.model.flow.UploadFile;
    import com.tiduyun.cmp.common.model.operation.ComponentInfo;
    import com.tiduyun.cmp.common.model.operation.HostInfo;
    import com.tiduyun.cmp.common.provider.service.ExceptionBuildService;
    import com.tiduyun.cmp.operation.constant.OperationExceptionCode;
    import com.tiduyun.cmp.operation.constant.StartCmdSeparate;
    import com.tiduyun.cmp.operation.model.AnsibleConfigurationItemVo;
    import com.tiduyun.cmp.operation.model.vo.FileQueryVo;
    import com.tiduyun.cmp.operation.service.AnsibleTaskRecordService;
    import com.tiduyun.cmp.operation.service.ComposerDeployService;
    import com.tiduyun.cmp.operation.service.HostInfoService;
    import com.tiduyun.cmp.operation.service.UploadFileService;
    import com.tiduyun.cmp.operation.utils.AnsibleExecuteTheOrderUtils;
    import lombok.extern.slf4j.Slf4j;
    import org.apache.commons.collections4.CollectionUtils;
    import org.apache.commons.lang3.StringUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    
    import java.io.File;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    @Slf4j
    @Service
    public class AnsibleDeployServiceImpl implements ComposerDeployService {
    
        @Value(value = "${cmp.operation.commandHeader:cmd /c}")
        private String commandHeader;
    
        @Value(value = "${cmp.operation.filePath:/data/cmp/file}")
        private String filePath;
    
        @Value(value = "${cmp.operation.remoteFilePath:/tmp}")
        private String remoteFilePath;
    
        @Autowired
        private AnsibleTaskRecordService ansibleTaskRecordService;
    
        @Autowired
        private AnsibleConfigurationItemVo ansibleConfigurationItemVo;
    
        @Autowired
        private UploadFileService uploadFileService;
    
        @Autowired
        private HostInfoService hostInfoService;
    
        @Autowired
        private ExceptionBuildService exceptionBuildService;
    
        @Override
        public void deploy(HostInfo hostInfo, ComponentInfo componentInfo, String cpmposerName) {
            ansibleTaskRecordService.ansibleCreateHost(hostInfo, null);
    
            try {
                String remotePath = StringUtils.join(remoteFilePath, "/", cpmposerName, "-", componentInfo.getName(), "-",
                    RandomUtil.randomString(3));
                log.info("remote file path = {}", remotePath);
    
                List fileIds = getFileIds(componentInfo.getFileUrl());
                if (CollectionUtils.isNotEmpty(fileIds)) {
                    FileQueryVo uploadFileQueryVo = new FileQueryVo();
                    uploadFileQueryVo.setIds(fileIds);
                    List uploadFiles = uploadFileService.query(uploadFileQueryVo);
                    for (UploadFile uploadFile : uploadFiles) {
                        String path = StringUtils.join(filePath, uploadFile.getFilePath());
                        File file = new File(path);
                        if (!file.exists()) {
                            log.error("file url is {}", file.getPath());
                            throw exceptionBuildService.buildException(OperationExceptionCode.FILE_NOT_EXIST,
                                new Object[] {uploadFile.getFileName()});
                        }
                        // 创建远程目录
                        AnsibleExecuteTheOrderUtils.createRemoteDirectory(ansibleConfigurationItemVo.getHostGroup(),
                            StringUtils.join(remotePath), ansibleConfigurationItemVo.getDirectory());
    
                        // 分发文件
                        AnsibleExecuteTheOrderUtils.upload(ansibleConfigurationItemVo.getHostGroup(), path,
                            StringUtils.join(remotePath, "/", uploadFile.getFileName()),
                            ansibleConfigurationItemVo.getDirectory());
                    }
                }
                List startCmds = getStartCmds(componentInfo.getStartCmd());
                if (CollectionUtils.isNotEmpty(startCmds)) {
                    String cdCmd = StringUtils.join("cd ", remotePath);
                    String execCmd = StringUtils.join(startCmds, ";");
                    execCmd = StringUtils.join(cdCmd, ";", execCmd);
                    log.info("execCmd= " + execCmd);
                    // sshClient.execute(execCmd);
                    AnsibleExecuteTheOrderUtils.ExecuteTheOrder(execCmd);
    
                } else {
                    log.error("parse startCmd fail {}", componentInfo.getStartCmd());
                }
    
            } catch (Exception e) {
                log.error("主机[{}]部署[{}]组件失败,主机ID[{}],组件ID[{}]:", hostInfo.getHost(), componentInfo.getName(),
                    hostInfo.getId(), componentInfo.getId(), e);
                throw exceptionBuildService.buildException(OperationExceptionCode.EXECUTE_CMD_ERROR,
                    new Object[] {e.getMessage()});
    
            } finally {
                AnsibleExecuteTheOrderUtils.disconnect();
            }
    
        }
    
        @Override
        public boolean isSupport(HostInfo hostInfo) {
            return true;
        }
    
        private List getFileIds(String fileIds) {
            List ids = new ArrayList<>();
            if (fileIds == null) {
                return null;
            }
            String[] split = StringUtils.split(fileIds, ",");
            for (String s : split) {
                ids.add(Integer.parseInt(s));
            }
            return ids;
        }
    
        private List getStartCmds(String startCmd) {
            List cmd = new ArrayList<>();
            if (startCmd == null) {
                return cmd;
            }
            String[] split = StrUtil.split(startCmd, StartCmdSeparate.SIGN);
            cmd.addAll(Arrays.asList(split));
            return cmd;
    
        }
    
        public static Boolean needCd(String s) {
            String[] splits = StrUtil.split(s, "&&");
            int maxIndex = splits.length - 1;
            String cmd = splits[maxIndex];
            if (StrUtil.startWith(cmd, "cd")) {
                return false;
            } else {
                return true;
            }
    
        }
    }

    文件采集

    同上,调用两个工具类

    @Override
        public void fileCollection(HostInfo hostInfo, String remotePath, String localPath) {
            ansibleCreateHost(hostInfo, null);
            try {
                log.info("remote file path = {}", remotePath);
                log.info("local file path = {}", localPath);
    
                // 文件采集
                AnsibleExecuteTheOrderUtils.fileCollection(ansibleConfigurationItemVo.getHostGroup(), remotePath,
                    localPath , ansibleConfigurationItemVo.getDirectory());
            } catch (Exception e) {
                log.error("主机[{}]文件采集失败,主机ID[{}]:", hostInfo.getHost(), hostInfo.getId(), e);
                throw exceptionBuildService.buildException(OperationExceptionCode.EXECUTE_CMD_ERROR,
                    new Object[] {e.getMessage()});
    
            } finally {
                AnsibleExecuteTheOrderUtils.disconnect();
            }
    
        }
    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发 Java
    相关文章 更多
    Yandex官网入口及网页搜索使用方法
    Yandex官网入口及网页搜索使用方法

    Yandex官网入口是https://www.yondex.net/,该平台支持多语言切换、智能搜索匹配、虚拟键盘变更及实时翻译,提供地图、图片、新闻、购物等垂直服务,并具备账户同步、隐私管理、个性化首页和云存储等功能。

    Java单元测试入门:使用JUnit 5编写第一个测试用例
    Java单元测试入门:使用JUnit 5编写第一个测试用例

    面向初学者的JUnit 5实用入门指南。从测试概念、Maven依赖配置,到手把手编写首个单元测试用例及断言验证,助你掌握Java单元测试的核心流程。

    Java变量未初始化报错解析:局部变量与成员变量默认值差异
    Java变量未初始化报错解析:局部变量与成员变量默认值差异

    深入解析Java中局部变量未初始化编译报错与成员变量自动赋予默认值的机制差异,涵盖JVM内存分配、编译期确定性赋值检查与实际排查修复方案。

    Java获取当前时间并格式化输出:DateTimeFormatter与SimpleDateFormat
    Java获取当前时间并格式化输出:DateTimeFormatter与SimpleDateFormat

    详细讲解在Java中获取当前系统时间并进行格式化输出的两种核心方案:基于Java 8全新日期时间API的DateTimeFormatter与传统遗留的SimpleDateFormat,包含完整代码示例、线程安全机制对比及生产选型建议。

    Java中final与static final常量的定义及初始化规则
    Java中final与static final常量的定义及初始化规则

    深入解析Java中final变量与static final常量的定义、内存语义、初始化时机及合法赋值路径,涵盖编译期常量优化与实战避坑指南。

    Java抽象方法与接口方法的区别及选型建议
    Java抽象方法与接口方法的区别及选型建议

    深入对比Java中抽象类抽象方法与接口方法的语法演进、设计意图及运行期差异,并提供清晰的架构选型决策流程与实战范例。

    Java实现HTTP请求与JSON解析的完整代码示例
    Java实现HTTP请求与JSON解析的完整代码示例

    本文提供Java标准库HttpClient发起HTTP GET/POST请求并结合Jackson进行JSON数据反序列化与序列化的完整代码示例与工程实践指南。

    Java递归出现StackOverflowError的原因分析及栈空间优化方案
    Java递归出现StackOverflowError的原因分析及栈空间优化方案

    详细分析Java递归调用出现StackOverflowError的原因,结合代码说明线程栈、栈帧和递归深度之间的关系,并介绍终止条件排查、迭代改写、减少栈帧开销以及通过-Xss调整JVM栈空间的方法。

    Java空指针异常(NPE)的代码排查与修复实例
    Java空指针异常(NPE)的代码排查与修复实例

    针对Java中常见的NullPointerException(NPE),本文从堆栈日志定位、典型代码触发场景、具体修复代码对比到防御体系进行系统讲解,提供实用且易上手的排查与修复方案。

    selenium上传文件教程本地文件路径设置方法
    selenium上传文件教程本地文件路径设置方法

    深入解析Selenium处理文件上传的技术细节,涵盖标准HTML控件的路径直接注入法与非标准控件的系统级模拟方案,提供Windows与Linux环境下的路径设置最佳实践及常见异常排查。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。