Java és JDBC használata rugalmas Azure Database for MySQL-kiszolgálóval
A következőkre vonatkozik: Azure Database for MySQL – rugalmas kiszolgáló
Ez a témakör bemutatja, hogyan hozhat létre egy mintaalkalmazást, amely Java és JDBC használatával tárolja és kéri le az adatokat a rugalmas Azure Database for MySQL-kiszolgálón.
A JDBC a hagyományos relációs adatbázisokhoz való csatlakozás szabványos Java API-ja.
Ebben a cikkben két hitelesítési módszert fogunk tartalmazni: a Microsoft Entra-hitelesítést és a MySQL-hitelesítést. A Jelszó nélküli lapon a Microsoft Entra-hitelesítés, a Jelszó lapon pedig a MySQL-hitelesítés látható.
A Microsoft Entra-hitelesítés a Rugalmas Azure Database for MySQL-kiszolgálóhoz való csatlakozás mechanizmusa a Microsoft Entra ID-ban meghatározott identitások használatával. A Microsoft Entra-hitelesítéssel központi helyen kezelheti az adatbázis felhasználói identitásait és más Microsoft-szolgáltatások, ami leegyszerűsíti az engedélykezelést.
A MySQL-hitelesítés a MySQL-ben tárolt fiókokat használja. Ha jelszavakat használ a fiókok hitelesítő adataiként, ezeket a hitelesítő adatokat a rendszer a user
táblában tárolja. Mivel ezek a jelszavak a MySQL-ben vannak tárolva, saját maga kell kezelnie a jelszavak rotálását.
Előfeltételek
- Aktív előfizetéssel rendelkező Azure-fiók. Ha nem rendelkezik Azure-előfizetéssel, a kezdés előtt hozzon létre egy ingyenes Azure-fiókot . Jelenleg ingyenes Azure-fiókkal 12 hónapig ingyenesen kipróbálhatja a Rugalmas Azure Database for MySQL-kiszolgálót. További információ: Azure Database for MySQL – Rugalmas kiszolgáló ingyenes kipróbálás.
- Azure Cloud Shell vagy Azure CLI. Az Azure Cloud Shell használatát javasoljuk, mert így automatikusan bejelentkezhet, és minden szükséges eszközt elérhet.
- Támogatott Java Development Kit, 8-es verzió (az Azure Cloud Shell része).
- Az Apache Maven buildelési eszköze.
A munkakörnyezet előkészítése
Először a következő paranccsal állítson be néhány környezeti változót.
export AZ_RESOURCE_GROUP=database-workshop
export AZ_DATABASE_NAME=<YOUR_DATABASE_NAME>
export AZ_LOCATION=<YOUR_AZURE_REGION>
export AZ_MYSQL_AD_NON_ADMIN_USERNAME=demo-non-admin
export AZ_USER_IDENTITY_NAME=<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>
export CURRENT_USERNAME=$(az ad signed-in-user show --query userPrincipalName -o tsv)
export CURRENT_USER_OBJECTID=$(az ad signed-in-user show --query id -o tsv)
A helyőrzőket írja felül a következő értékekkel, amelyeket a cikk teljes további részében használni fogunk:
<YOUR_DATABASE_NAME>
: A rugalmas Azure Database for MySQL-kiszolgálópéldány neve, amelynek egyedinek kell lennie az Azure-ban.<YOUR_AZURE_REGION>
: A használni kívánt Azure-régió. Használhatja az alapértelmezetteastus
értéket, de ajánlott az Ön lakóhelyéhez közelebbi régiót konfigurálni. Az elérhető régiók teljes listáját a beírássalaz account list-locations
tekintheti meg.<YOUR_USER_ASSIGNED_MANAGED_IDENTITY_NAME>
: A felhasználó által hozzárendelt felügyelt identitáskiszolgáló neve, amelynek egyedinek kell lennie az Azure-ban.
Ez után hozzon létre egy erőforráscsoportot:
az group create \
--name $AZ_RESOURCE_GROUP \
--location $AZ_LOCATION \
--output tsv
Azure Database for MySQL-példány létrehozása
Rugalmas Azure Database for MySQL-kiszolgálópéldány létrehozása és rendszergazdai felhasználó beállítása
Elsőként egy rugalmas Azure Database for MySQL-kiszolgálópéldányt hoz létre.
Feljegyzés
A Rugalmas Azure Database for MySQL-kiszolgálópéldány létrehozásával kapcsolatos részletesebb információkat az Azure Portal használatával olvashatja el.
Ha Azure CLI-t használ, futtassa a következő parancsot, hogy meggyőződjön arról, hogy rendelkezik-e megfelelő engedéllyel:
az login --scope https://graph.microsoft.com/.default
Futtassa a következő parancsot a kiszolgáló létrehozásához:
az mysql flexible-server create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_NAME \
--location $AZ_LOCATION \
--yes \
--output tsv
Futtassa a következő parancsot egy felhasználó által hozzárendelt identitás létrehozásához:
az identity create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_USER_IDENTITY_NAME
Fontos
A felhasználó által hozzárendelt identitás létrehozása után kérje meg a globális rendszergazdát vagy a kiemelt szerepkör-rendszergazdát, hogy adja meg az alábbi engedélyeket ehhez az identitáshoz: User.Read.All
, GroupMember.Read.All
és Application.Read.ALL
. További információ: Az Active Directory-hitelesítés Engedélyek szakasza.
Futtassa a következő parancsot az identitás rugalmas Azure Database for MySQL-kiszolgálóhoz való hozzárendeléséhez a Microsoft Entra-rendszergazda létrehozásához:
az mysql flexible-server identity assign \
--resource-group $AZ_RESOURCE_GROUP \
--server-name $AZ_DATABASE_NAME \
--identity $AZ_USER_IDENTITY_NAME
Futtassa a következő parancsot a Microsoft Entra rendszergazdai felhasználójának beállításához:
az mysql flexible-server ad-admin create \
--resource-group $AZ_RESOURCE_GROUP \
--server-name $AZ_DATABASE_NAME \
--display-name $CURRENT_USERNAME \
--object-id $CURRENT_USER_OBJECTID \
--identity $AZ_USER_IDENTITY_NAME
Fontos
A rendszergazda beállításakor a rendszer új felhasználót ad hozzá a rugalmas Azure Database for MySQL-kiszolgálópéldányhoz teljes rendszergazdai engedélyekkel. Rugalmas Azure Database for MySQL-kiszolgálópéldányonként csak egy Microsoft Entra-rendszergazda hozható létre, és egy másik kiválasztása felülírja a kiszolgálóhoz konfigurált meglévő Microsoft Entra-rendszergazdat.
Ez a parancs egy rugalmas Azure Database for MySQL-kiszolgálópéldányt hoz létre, és az Active Directory-rendszergazdát a bejelentkezett felhasználóra állítja.
A létrehozott rugalmas Azure Database for MySQL-kiszolgálópéldánynak van egy üres, úgynevezett adatbázisa flexibleserverdb
.
Problémái vannak? Tudassa velünk.
Tűzfalszabály konfigurálása rugalmas Azure Database for MySQL-kiszolgálópéldányhoz
A rugalmas Azure Database for MySQL-kiszolgálópéldányok alapértelmezés szerint védettek. Tűzfallal rendelkezik, amely semmilyen bejövő kapcsolatot sem engedélyez.
Ezt a lépést kihagyhatja, ha Basht használ, mert a flexible-server create
parancs már észlelte a helyi IP-címet, és beállította a MySQL-kiszolgálón.
Ha rugalmas Azure Database for MySQL-kiszolgálópéldányhoz csatlakozik Linuxos Windows-alrendszer (WSL) egy Windows-számítógépen, hozzá kell adnia a WSL-gazdagép azonosítóját a tűzfalhoz. Szerezze be a gazdagép IP-címét a következő parancs WSL-ben való futtatásával:
sudo cat /etc/resolv.conf
Másolja ki az IP-címet a kifejezés nameserver
után, majd az alábbi paranccsal állítson be környezeti változót a WSL IP-címéhez:
AZ_WSL_IP_ADDRESS=<the-copied-IP-address>
Ezután a következő paranccsal nyissa meg a kiszolgáló tűzfalát a WSL-alapú alkalmazás számára:
az mysql flexible-server firewall-rule create \
--resource-group $AZ_RESOURCE_GROUP \
--name $AZ_DATABASE_NAME \
--start-ip-address $AZ_WSL_IP_ADDRESS \
--end-ip-address $AZ_WSL_IP_ADDRESS \
--rule-name allowiprange \
--output tsv
MySQL-adatbázis konfigurálása
Hozzon létre egy új, az alábbi paranccsal hívott demo
adatbázist:
az mysql flexible-server db create \
--resource-group $AZ_RESOURCE_GROUP \
--database-name demo \
--server-name $AZ_DATABASE_NAME \
--output tsv
Nem rendszergazdai MySQL-felhasználó létrehozása és engedély megadása
Ezután hozzon létre egy nem rendszergazdai felhasználót, és adjon meg neki minden engedélyt az demo
adatbázishoz.
Feljegyzés
A MySQL-felhasználók létrehozásáról az Azure Database for MySQL-ben a Felhasználók létrehozása szolgáltatásban olvashat részletesebben.
Hozzon létre egy create_ad_user.sql nevű SQL-szkriptet, amely nem rendszergazdai felhasználót hoz létre. Adja hozzá a következő tartalmat, és mentse helyileg:
export AZ_MYSQL_AD_NON_ADMIN_USERID=$(az ad signed-in-user show --query id --output tsv)
cat << EOF > create_ad_user.sql
SET aad_auth_validate_oids_in_tenant = OFF;
CREATE AADUSER '$AZ_MYSQL_AD_NON_ADMIN_USERNAME' IDENTIFIED BY '$AZ_MYSQL_AD_NON_ADMIN_USERID';
GRANT ALL PRIVILEGES ON demo.* TO '$AZ_MYSQL_AD_NON_ADMIN_USERNAME'@'%';
FLUSH privileges;
EOF
Ezután az alábbi paranccsal futtassa az SQL-szkriptet a Microsoft Entra nem rendszergazdai felhasználójának létrehozásához:
mysql -h $AZ_DATABASE_NAME.mysql.database.azure.com --user $CURRENT_USERNAME --enable-cleartext-plugin --password=$(az account get-access-token --resource-type oss-rdbms --output tsv --query accessToken) < create_ad_user.sql
Most az alábbi paranccsal távolítsa el az ideiglenes SQL-szkriptfájlt:
rm create_ad_user.sql
Új Java-projekt létrehozása
A kedvenc IDE használatával hozzon létre egy új Java-projektet, és vegyen fel egy pom.xml fájlt a gyökérkönyvtárába:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<properties>
<java.version>1.8</java.version>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
<dependency>
<groupId>com.azure</groupId>
<artifactId>azure-identity-extensions</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
</project>
Ez a fájl egy Apache Maven-fájl , amely a projekt használatát konfigurálja:
- Java 8
- A Legutóbbi MySQL-illesztőprogram Java-hoz
Konfigurációs fájl előkészítése az Azure Database for MySQL-hez való csatlakozáshoz
Futtassa a következő szkriptet a projekt gyökérkönyvtárában egy src/main/resources/database.properties fájl létrehozásához, és adja hozzá a konfiguráció részleteit:
mkdir -p src/main/resources && touch src/main/resources/database.properties
cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_NAME}.mysql.database.azure.com:3306/demo?sslMode=REQUIRED&serverTimezone=UTC&defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin
user=${AZ_MYSQL_AD_NON_ADMIN_USERNAME}
EOF
Feljegyzés
Ha a MysqlConnectionPoolDataSource osztályt használja adatforrásként az alkalmazásban, távolítsa el a "defaultAuthenticationPlugin=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin" címet az URL-címből.
mkdir -p src/main/resources && touch src/main/resources/database.properties
cat << EOF > src/main/resources/database.properties
url=jdbc:mysql://${AZ_DATABASE_NAME}.mysql.database.azure.com:3306/demo?sslMode=REQUIRED&serverTimezone=UTC&authenticationPlugins=com.azure.identity.extensions.jdbc.mysql.AzureMysqlAuthenticationPlugin
user=${AZ_MYSQL_AD_NON_ADMIN_USERNAME}
EOF
Feljegyzés
A konfigurációs tulajdonság url
hozzá lett ?serverTimezone=UTC
fűzve, hogy a JDBC-illesztő az UTC dátumformátumot (vagy az egyezményes világidőt) használja az adatbázishoz való csatlakozáskor. Ellenkező esetben a Java-kiszolgáló nem ugyanazt a dátumformátumot használja, mint az adatbázis, ami hibát eredményezne.
SQL-fájl létrehozása az adatbázisséma létrehozásához
Adatbázisséma létrehozásához src /main/resources/schema.sql fájlt fog használni. Hozza létre a fájlt a következő tartalommal:
DROP TABLE IF EXISTS todo;
CREATE TABLE todo (id SERIAL PRIMARY KEY, description VARCHAR(255), details VARCHAR(4096), done BOOLEAN);
Az alkalmazás kódolása
Csatlakozás az adatbázishoz
Ezután adja hozzá azt a Java-kódot, amely A JDBC használatával tárolja és kéri le az adatokat a MySQL-kiszolgálóról.
Hozzon létre egy src/main/java/DemoApplication.java fájlt, és adja hozzá a következő tartalmat:
package com.example.demo;
import com.mysql.cj.jdbc.AbandonedConnectionCleanupThread;
import java.sql.*;
import java.util.*;
import java.util.logging.Logger;
public class DemoApplication {
private static final Logger log;
static {
System.setProperty("java.util.logging.SimpleFormatter.format", "[%4$-7s] %5$s %n");
log =Logger.getLogger(DemoApplication.class.getName());
}
public static void main(String[] args) throws Exception {
log.info("Loading application properties");
Properties properties = new Properties();
properties.load(DemoApplication.class.getClassLoader().getResourceAsStream("database.properties"));
log.info("Connecting to the database");
Connection connection = DriverManager.getConnection(properties.getProperty("url"), properties);
log.info("Database connection test: " + connection.getCatalog());
log.info("Create database schema");
Scanner scanner = new Scanner(DemoApplication.class.getClassLoader().getResourceAsStream("schema.sql"));
Statement statement = connection.createStatement();
while (scanner.hasNextLine()) {
statement.execute(scanner.nextLine());
}
/*
Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
insertData(todo, connection);
todo = readData(connection);
todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);
deleteData(todo, connection);
*/
log.info("Closing database connection");
connection.close();
AbandonedConnectionCleanupThread.uncheckedShutdown();
}
}
Problémái vannak? Tudassa velünk.
Ez a Java-kód a korábban létrehozott database.properties és schema.sql fájlokat fogja használni, hogy csatlakozzon a rugalmas Azure Database for MySQL-kiszolgálópéldányhoz, és hozzon létre egy sémát, amely tárolja az adatokat.
Ebben a fájlban láthatja, hogy megjegyzéseket fűztünk az adatok beszúrásához, olvasásához, frissítéséhez és törléséhez: ezeket a metódusokat a cikk további részében fogja kódolva, és egymás után is feloldhatja őket.
Feljegyzés
Az adatbázis hitelesítő adatai a database.properties fájl felhasználói és jelszótulajdonságaiban vannak tárolva . Ezeket a hitelesítő adatokat a rendszer a végrehajtás DriverManager.getConnection(properties.getProperty("url"), properties);
során használja, mivel a tulajdonságfájl argumentumként lesz átadva.
Feljegyzés
A AbandonedConnectionCleanupThread.uncheckedShutdown();
sor végén egy MySQL-illesztőprogram-specifikus parancs található, amely elpusztít egy belső szálat az alkalmazás leállításakor.
Biztonságosan figyelmen kívül hagyható.
Most már végrehajthatja ezt a főosztályt a kedvenc eszközével:
- Az IDE használatával a jobb gombbal a DemoApplication osztályra kell kattintania, és végre kell hajtania.
- A Maven használatával futtathatja az alkalmazást a következő végrehajtásával:
mvn exec:java -Dexec.mainClass="com.example.demo.DemoApplication"
.
Az alkalmazásnak csatlakoznia kell a rugalmas Azure Database for MySQL-kiszolgálópéldányhoz, létre kell hoznia egy adatbázissémát, majd be kell zárnia a kapcsolatot, ahogy a konzolnaplókban látnia kell:
[INFO ] Loading application properties
[INFO ] Connecting to the database
[INFO ] Database connection test: demo
[INFO ] Create database schema
[INFO ] Closing database connection
Tartományosztály létrehozása
Hozzon létre egy új Todo
Java-osztályt az DemoApplication
osztály mellett, és adja hozzá a következő kódot:
package com.example.demo;
public class Todo {
private Long id;
private String description;
private String details;
private boolean done;
public Todo() {
}
public Todo(Long id, String description, String details, boolean done) {
this.id = id;
this.description = description;
this.details = details;
this.done = done;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
public String getDetails() {
return details;
}
public void setDetails(String details) {
this.details = details;
}
public boolean isDone() {
return done;
}
public void setDone(boolean done) {
this.done = done;
}
@Override
public String toString() {
return "Todo{" +
"id=" + id +
", description='" + description + '\'' +
", details='" + details + '\'' +
", done=" + done +
'}';
}
}
Ez az osztály a schema.sql szkript végrehajtásakor létrehozott táblán todo
leképezett tartománymodell.
Adatok beszúrása az Azure Database for MySQL-be
Az src/main/java/DemoApplication.java fájlban a fő metódus után adja hozzá a következő metódust az adatok adatbázisba való beszúrásához:
private static void insertData(Todo todo, Connection connection) throws SQLException {
log.info("Insert data");
PreparedStatement insertStatement = connection
.prepareStatement("INSERT INTO todo (id, description, details, done) VALUES (?, ?, ?, ?);");
insertStatement.setLong(1, todo.getId());
insertStatement.setString(2, todo.getDescription());
insertStatement.setString(3, todo.getDetails());
insertStatement.setBoolean(4, todo.isDone());
insertStatement.executeUpdate();
}
A metódusban most már feloldhatja a következő két sort main
:
Todo todo = new Todo(1L, "configuration", "congratulations, you have set up JDBC correctly!", true);
insertData(todo, connection);
A főosztály végrehajtásának most a következő kimenetet kell eredményeznie:
[INFO ] Loading application properties
[INFO ] Connecting to the database
[INFO ] Database connection test: demo
[INFO ] Create database schema
[INFO ] Insert data
[INFO ] Closing database connection
Adatok olvasása az Azure Database for MySQL-ből
Ezután olvassa el a korábban beszúrt adatokat annak ellenőrzéséhez, hogy a kód megfelelően működik-e.
Az src/main/java/DemoApplication.java fájlban a insertData
metódus után adja hozzá a következő metódust az adatok adatbázisból való beolvasásához:
private static Todo readData(Connection connection) throws SQLException {
log.info("Read data");
PreparedStatement readStatement = connection.prepareStatement("SELECT * FROM todo;");
ResultSet resultSet = readStatement.executeQuery();
if (!resultSet.next()) {
log.info("There is no data in the database!");
return null;
}
Todo todo = new Todo();
todo.setId(resultSet.getLong("id"));
todo.setDescription(resultSet.getString("description"));
todo.setDetails(resultSet.getString("details"));
todo.setDone(resultSet.getBoolean("done"));
log.info("Data read from the database: " + todo.toString());
return todo;
}
Most már feloldhatja a következő sort a main
metódusban:
todo = readData(connection);
A főosztály végrehajtásának most a következő kimenetet kell eredményeznie:
[INFO ] Loading application properties
[INFO ] Connecting to the database
[INFO ] Database connection test: demo
[INFO ] Create database schema
[INFO ] Insert data
[INFO ] Read data
[INFO ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO ] Closing database connection
Problémái vannak? Tudassa velünk.
Adatok frissítése rugalmas Azure Database for MySQL-kiszolgálón
Ezután frissítse a korábban beszúrt adatokat.
Az src/main/java/DemoApplication.java fájlban a metódus után readData
adja hozzá a következő metódust az adatbázison belüli adatok frissítéséhez:
private static void updateData(Todo todo, Connection connection) throws SQLException {
log.info("Update data");
PreparedStatement updateStatement = connection
.prepareStatement("UPDATE todo SET description = ?, details = ?, done = ? WHERE id = ?;");
updateStatement.setString(1, todo.getDescription());
updateStatement.setString(2, todo.getDetails());
updateStatement.setBoolean(3, todo.isDone());
updateStatement.setLong(4, todo.getId());
updateStatement.executeUpdate();
readData(connection);
}
A metódusban most már feloldhatja a következő két sort main
:
todo.setDetails("congratulations, you have updated data!");
updateData(todo, connection);
A főosztály végrehajtásának most a következő kimenetet kell eredményeznie:
[INFO ] Loading application properties
[INFO ] Connecting to the database
[INFO ] Database connection test: demo
[INFO ] Create database schema
[INFO ] Insert data
[INFO ] Read data
[INFO ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO ] Update data
[INFO ] Read data
[INFO ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true}
[INFO ] Closing database connection
Adatok törlése rugalmas Azure Database for MySQL-kiszolgálón
Végül törölje a korábban beszúrt adatokat.
Az src/main/java/DemoApplication.java fájlban a metódus után updateData
adja hozzá a következő metódust az adatbázisban lévő adatok törléséhez:
private static void deleteData(Todo todo, Connection connection) throws SQLException {
log.info("Delete data");
PreparedStatement deleteStatement = connection.prepareStatement("DELETE FROM todo WHERE id = ?;");
deleteStatement.setLong(1, todo.getId());
deleteStatement.executeUpdate();
readData(connection);
}
Most már feloldhatja a következő sort a main
metódusban:
deleteData(todo, connection);
A főosztály végrehajtásának most a következő kimenetet kell eredményeznie:
[INFO ] Loading application properties
[INFO ] Connecting to the database
[INFO ] Database connection test: demo
[INFO ] Create database schema
[INFO ] Insert data
[INFO ] Read data
[INFO ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have set up JDBC correctly!', done=true}
[INFO ] Update data
[INFO ] Read data
[INFO ] Data read from the database: Todo{id=1, description='configuration', details='congratulations, you have updated data!', done=true}
[INFO ] Delete data
[INFO ] Read data
[INFO ] There is no data in the database!
[INFO ] Closing database connection
Az erőforrások eltávolítása
Gratulálunk! Létrehozott egy Java-alkalmazást, amely JDBC használatával tárolja és kéri le az adatokat a rugalmas Azure Database for MySQL-kiszolgálóról.
A rövid útmutató során használt összes erőforrás törléséhez törölje az erőforráscsoportot az alábbi paranccsal:
az group delete \
--name $AZ_RESOURCE_GROUP \
--yes