--- title: "Mengirim surel" version: 4.0 locale: id source: https://docs.djangoproject.com/id/4.0/topics/email/ canonical: https://djangodocs.dev/id/4.0/topics/email/ --- # Mengirim surel Although Python provides a mail sending interface via the [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib) module, Django provides a couple of light wrappers over it. These wrappers are provided to make sending email extra quick, to help test email sending during development, and to provide support for platforms that can't use SMTP. Kode tinggal dalam modul `django.core.mail`. ## Contoh cepat Dalam dua baris: ``` from django.core.mail import send_mail send_mail( 'Subject here', 'Here is the message.', 'from@example.com', ['to@example.com'], fail_silently=False, ) ``` Surat dikirim menggunakan rumah SMTP dan port ditentukan dalam pengaturan [`EMAIL_HOST`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST) dan [`EMAIL_PORT`](/id/4.0/ref/settings/#std-setting-EMAIL_PORT). Pengaturan [`EMAIL_HOST_USER`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST_USER) dan [`EMAIL_HOST_PASSWORD`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) settings, jika disetel, digunakan untuk mengotentifikasi pada peladen SMTP, dan pengaturan [`EMAIL_USE_TLS`](/id/4.0/ref/settings/#std-setting-EMAIL_USE_TLS) dan [`EMAIL_USE_SSL`](/id/4.0/ref/settings/#std-setting-EMAIL_USE_SSL) mengendalikan apakah hubungan aman digunakan. > **Note** > > Kumpulan karakter dari surel dikirim dengan `django.core.mail` akan disetel ke nilai dari pengaturan [`DEFAULT_CHARSET`](/id/4.0/ref/settings/#std-setting-DEFAULT_CHARSET) anda. ## `send_mail()` #### `send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)` Dalam kebanyakan kasus, anda dapat mengirim surel menggunakan `django.core.mail.send_mail()`. Parameter `subject`, `message`, `from_email` dan `recipient_list` dibutuhkan. - `subject`: Sebuah string. - `message`: Sebuah string. - `from_email`: Sebuah string. Jika `None`, Django aan menggunakan nilai dari pengaturan [`DEFAULT_FROM_EMAIL`](/id/4.0/ref/settings/#std-setting-DEFAULT_FROM_EMAIL). - `recipient_list`: Sebuah daftar dari string, setiap alamat surel. Setiap anggota dari `recipient_list` akan melihat penerima lain dalam bidang "To:" dari pesan surel. - `fail_silently`: A boolean. When it's `False`, `send_mail()` will raise an [`smtplib.SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException) if an error occurs. See the [`smtplib`](https://docs.python.org/3/library/smtplib.html#module-smtplib) docs for a list of possible exceptions, all of which are subclasses of [`SMTPException`](https://docs.python.org/3/library/smtplib.html#smtplib.SMTPException). - `auth_user`: Pilihan nama pengguna untuk digunakan mengautentifikasi ke peladen SMTP. Jika ini tidak disediakan, Django akan menggunakan nilai dari pengaturan [`EMAIL_HOST_USER`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST_USER). - `auth_password`: Sandi pilihan digunakan untuk mengautentifikasi ke peladen SMTP. Jika ini tidak disediakan, Django akan menggunakan nilai dari pengaturan [`EMAIL_HOST_PASSWORD`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) - `connection`: Backend surel pilihan digunakan untuk mengirim surat. Jika tidak ditentukan, sebuah instance dari backend awalan akan digunakan. Lihat dokumentasi pada Email backends 1 untuk rincian lebih. - `html_message`: Jika `html_message` disediakan, surel dihasilkan akan berupa surel `multipart/alternative` dengan `message` sebagai jenis isi `text/plain` dan `html_message` sebagai jenis isi `text/html`. Nilai kembalian akan berupa angka dari pesan terkirim yang berhasil (yang dapat berupa `0` atau `1` sejak itu hanya daoat mengirim satu pesan). ## `send_mass_mail()` #### `send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)` `django.core.mail.send_mass_mail()` diperuntukkan untuk menangani penyuratan elektronik masal. `datatuple` adalah sebuah tuple yang setiap unsur adalah dalam bentuk ini: ``` (subject, message, from_email, recipient_list) ``` `fail_silently`, `auth_user` dan `auth_password` mempunyai fungsi sama seperti dalam [`send_mail()`](#django.core.mail.send_mail). Setiap unsur terpisah dari `datatuple` menghasilkan dalam pesan surel terpisah. Seperti dalam [`send_mail()`](#django.core.mail.send_mail), penerima dalam `recipient_list` sama akan semua melihat alamat-alamat lain dalam pesan surel' bidang "To:". Sebagai contoh, kode berikut akan mengirim dua pesan berbeda pada dua kumpulan berbeda dari penerima; bagaimanapun, hanya satu hubungan ke peladen surat akan dibuka: ``` message1 = ('Subject here', 'Here is the message', 'from@example.com', ['first@example.com', 'other@example.com']) message2 = ('Another Subject', 'Here is another message', 'from@example.com', ['second@test.com']) send_mass_mail((message1, message2), fail_silently=False) ``` Nilai kembalian akan berupa angka dari pesan terkirim berhasil. ### `send_mass_mail()` x `send_mail()` Perbedaan utama diantara [`send_mass_mail()`](#django.core.mail.send_mass_mail) dan [`send_mail()`](#django.core.mail.send_mail) adalah bahwa [`send_mail()`](#django.core.mail.send_mail) membuka sebuah hubungan ke peladen surel setiap itu dijalankan, selagi [`send_mass_mail()`](#django.core.mail.send_mass_mail) menggunakan hubungan tunggal untuk semua pesan-pesannya. Ini membuat [`send_mass_mail()`](#django.core.mail.send_mass_mail) sedikit lebih efesien. ## `mail_admins()` #### `mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)` `django.core.mail.mail_admins()` adalah jalan pintas untuk mengirim sebuah surel pada admin situs, seperti ditentukan dalam pengaturan [`ADMINS`](/id/4.0/ref/settings/#std-setting-ADMINS). `mail_admins()` mengawali subyek dengan nilai dari pengaturan [`EMAIL_SUBJECT_PREFIX`](/id/4.0/ref/settings/#std-setting-EMAIL_SUBJECT_PREFIX), yaitu `"[Django] "` secara awalan. Kepala "From:" dari surel akan berupa nilai dari pengaturan [`SERVER_EMAIL`](/id/4.0/ref/settings/#std-setting-SERVER_EMAIL). Metode ini ada untuk kenyamanan dan kesiapan. Jika `html_message` disediakan, surel dihasilkan akan berupa surel `multipart/alternative` dengan `message` seperti jenis isi `text/plain` dan `html_message` seperti jenis isi `text/html`. ## `mail_managers()` #### `mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)` `django.core.mail.mail_managers()` seperti `mail_admins()`, kecuali itu mengirim sebuah surel ke pengelola situs, seperti ditentukan dalam pengaturan [`MANAGERS`](/id/4.0/ref/settings/#std-setting-MANAGERS). ## Contoh Ini mengirim surel tunggal kepada [john@example.com](mailto:john@example.com) dan [jane@example.com](mailto:jane@example.com), dengan keduanya mereka muncul dalam "To:": ``` send_mail( 'Subject', 'Message.', 'from@example.com', ['john@example.com', 'jane@example.com'], ) ``` Ini mengirim sebuah pesan ke [john@example.com](mailto:john@example.com) dan [jane@example.com](mailto:jane@example.com), dengan keduanya menerima surel terpisah: ``` datatuple = ( ('Subject', 'Message.', 'from@example.com', ['john@example.com']), ('Subject', 'Message.', 'from@example.com', ['jane@example.com']), ) send_mass_mail(datatuple) ``` ## Mencegah penyuntikan kepala [Header injection](http://www.nyphp.org/phundamentals/8_Preventing-Email-Header-Injection.html) adalah memanfaatkan keamanan dimana seorang penyerang memasukkan kepala surel tambahan untuk mengendalikan "To:" dan "From:" dalam pesan-pesan surel yang tulisan-tulisan anda dibangkitkan. Fungsi-fungsi surel Django diuraikan diatas semua dilindungi terhadap suntukan kepala dengan melarang baris baru dalam nilai kepala. Jika ada `subject`, `from_email` atau `recepient_list` mengandung sebuah baris baru (dalam salah satu gaya Unix, Windows, atau Mac), fungsi surel (sebagai contoh [`send_mail()`](#django.core.mail.send_mail)) akan memunculkan `django.core.mail.BadHeaderError` (sebuah subkelas dari `ValueError`) dan, karenanya, tidak akan mengirim surel. Itu adalah tanggung jawab anda untuk mengesahkan semua data sebelum melewatkan itu ke fungsi-fungsi surel. If a `message` contains headers at the start of the string, the headers will be printed as the first bit of the email message. Ini adalah sebuah contoh tampilan yang mengambil `subject`, `message` dan `from_email` dari data POST permintaan, mengirim itu ke [admin@example.com](mailto:admin@example.com) dan mengalihkan ke "/contact/thanks/" ketika itu selesai: ``` from django.core.mail import BadHeaderError, send_mail from django.http import HttpResponse, HttpResponseRedirect def send_email(request): subject = request.POST.get('subject', '') message = request.POST.get('message', '') from_email = request.POST.get('from_email', '') if subject and message and from_email: try: send_mail(subject, message, from_email, ['admin@example.com']) except BadHeaderError: return HttpResponse('Invalid header found.') return HttpResponseRedirect('/contact/thanks/') else: # In reality we'd use a form class # to get proper validation errors. return HttpResponse('Make sure all fields are entered and valid.') ``` ## Kelas `EmailMessage` Fungsi-fungsi [`send_mail()`](#django.core.mail.send_mail) dan [`send_mass_mail()`](#django.core.mail.send_mass_mail) sebenarnya pembungkus kecil yang memanfaatkan dari kelas [`EmailMessage`](#django.core.mail.EmailMessage). Tidak semua fitur dari kelas [`EmailMessage`](#django.core.mail.EmailMessage) tersedia melalui [`send_mail()`](#django.core.mail.send_mail) dan fungsi-fungsi pembungkus terkait. Jika anda menginginkan menggunakan fitur-fitur lanjutan, seperti penerima BCC, lampiran berkas, atau banyak-bagian surel, anda akan butuh membuat instance [`EmailMessage`](#django.core.mail.EmailMessage) langsung. > **Note** > > Ini adalah fitur rancangan. [`send_mail()`](#django.core.mail.send_mail) dan fungsi-fungsi terkait aslinya hanya antarmuka Django sediakan. Bagaimanapun, daftar dari parameter mereka terima pelan-pelan tumbuh terhadap waktu. Itu masuk akal memindahkan rancangan berorientasi-obyek untuk pesan-pesan surel dan memelihara fungsi-fungsi asli hanya untuk kesesuaian kebelakang. [`EmailMessage`](#django.core.mail.EmailMessage) bertanggungjawab untuk membuat pesan surel itu sendiri. email backend 1 kemudian bertanggungjawab untuk mengirim surel. For convenience, [`EmailMessage`](#django.core.mail.EmailMessage) provides a `send()` method for sending a single email. If you need to send multiple messages, the email backend API [provides an alternative](#topics-sending-multiple-emails). ### Obyek `EmailMessage` #### `class EmailMessage` Kelas [`EmailMessage`](#django.core.mail.EmailMessage) diawalkan dengan parameter-parameter berikut (dalam urutan diberikan, jika penempatan argumen-argumen digunakan). Semua parameter adalah pilihan dan dapat disetel pada waktu kapanpun sebelum memanggil metode `send()`. - `subject`: Pokok baris dari surel. - `body`: Teks badan. Ini harus berupa pesan teks polos. - `from_email`: The sender's address. Both `fred@example.com` and `"Fred" ` forms are legal. If omitted, the [`DEFAULT_FROM_EMAIL`](/id/4.0/ref/settings/#std-setting-DEFAULT_FROM_EMAIL) setting is used. - `to`: Sebuah list atau tuple dari alamat-alamat penerima. - `bcc`: Sebuah list atau tuple dari alamat-alamat digunakan dalam kepala "Bcc" ketika mengirim surel. - `connection`: Sebuah instance backend surel. Gunakan parameter ini jika anda ingin menggunakan hubungan sama untuk banyak pesan-pesan. Jika dihilangkan, hubungan baru dibuat ketika `send()` dipanggil. - `attachments`: A list of attachments to put on the message. These can be either [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) instances, or `(filename, content, mimetype)` triples. - `header`: Sebuah dictionary dari kepala tambahan untuk menaruh pesan. Kunci-kunci adalah nama kepala, nilai-nilai adalah nilai-nilai kepala. Itu terserah pada pemanggil untuk memastikan nama=nama dan nilai-nilai dalam bentuk benar untuk pesan surel. Atribut sesuai adalah `extra_headers`. - `cc`: Sebuah list atau tuple dari alamat-alamat penerima digunakan dalam kepala "Cc" ketika mengirim surel. - `reply_to`: Sebuah list atau tuple dari alamat-alamat penerima dalam kepala "Reply-To" ketika mengirim surel. Sebagai contoh: ``` from django.core.mail import EmailMessage email = EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to1@example.com', 'to2@example.com'], ['bcc@example.com'], reply_to=['another@example.com'], headers={'Message-ID': 'foo'}, ) ``` Kelas mempunyai cara berikut: - `send(fail_silently=False)` sends the message. If a connection was specified when the email was constructed, that connection will be used. Otherwise, an instance of the default backend will be instantiated and used. If the keyword argument `fail_silently` is `True`, exceptions raised while sending the message will be quashed. An empty list of recipients will not raise an exception. It will return `1` if the message was sent successfully, otherwise `0`. - `message()` constructs a `django.core.mail.SafeMIMEText` object (a subclass of Python's [`MIMEText`](https://docs.python.org/3/library/email.mime.html#email.mime.text.MIMEText) class) or a `django.core.mail.SafeMIMEMultipart` object holding the message to be sent. If you ever need to extend the [`EmailMessage`](#django.core.mail.EmailMessage) class, you'll probably want to override this method to put the content you want into the MIME object. - `recipients()` mengembalikan daftar dari semua penerima dari pesan, apakah mereka adalah terekam dalam atribut `to`, `cc` atau `bcc`. Ini adalah metode lain anda mungkin butuh untuk menimpa ketika mensubkelaskan, karena peladen SMTP butuh diberitahu daftar penuh dari penerima ketika pesan dikirim. Jika anda menambah cara lain untuk menentukan penerima dalam kelas anda, mereka butuh dikembalikan dari metode ini juga. - `attach()` membuat lampiran berkas baru dan menambahkan itu ke pesan. Ada dua cara memanggil `attach()`: - You can pass it a single argument that is a [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) instance. This will be inserted directly into the resulting message. - Kalau tidak, anda dapat melewatkan tiga argumen `attach()`: `filename`, `content` dan `mimetype`. `filename` adalah nama dari lampiran berkas ketika itu muncul dalam surel, `content` adalah data yang akan di isi didalam lampiran dan `mimetype` adalah jenis MIME untuk lampiran. Jika anda menghilangkan `mimetype`, jenis isi MIME akan ditebak dari nama berkas dari lampiran. Sebagai contoh: ``` message.attach('design.png', img_data, 'image/png') ``` If you specify a `mimetype` of `message/rfc822`, it will also accept [`django.core.mail.EmailMessage`](#django.core.mail.EmailMessage) and [`email.message.Message`](https://docs.python.org/3/library/email.compat32-message.html#email.message.Message). For a `mimetype` starting with `text/`, content is expected to be a string. Binary data will be decoded using UTF-8, and if that fails, the MIME type will be changed to `application/octet-stream` and the data will be attached unchanged. In addition, `message/rfc822` attachments will no longer be base64-encoded in violation of [**RFC 2046 Section 5.2.1**](https://datatracker.ietf.org/doc/html/rfc2046.html#section-5.2.1), which can cause issues with displaying the attachments in [Evolution](https://bugzilla.gnome.org/show_bug.cgi?id=651197) and [Thunderbird](https://bugzilla.mozilla.org/show_bug.cgi?id=333880). - `attach_file()` creates a new attachment using a file from your filesystem. Call it with the path of the file to attach and, optionally, the MIME type to use for the attachment. If the MIME type is omitted, it will be guessed from the filename. You can use it like this: ``` message.attach_file('/images/weather_map.png') ``` For MIME types starting with `text/`, binary data is handled as in `attach()`. #### Mengirim pilihan lain jenis isi Itu dapat sangat berguna untuk menyertakan banyak versi dari isi dalam sebuah surel; contoh klasik adalah mengirimkan kedua versi teks dan HTML dari pesan. Dengan pustaka surel Django, anda dapat melakukan ini menggunakan kelas `EmailMultiAlternatives`. Subkelas ini dari [`EmailMessage`](#django.core.mail.EmailMessage) mempunyai sebuah metode `attach_alternative()` untuk meneyrtakan versi tambahan dari badan pesan dalam surel. Semua metode lainnya (termasuk pengawalan kelas) diwariskan langsung dari [`EmailMessage`](#django.core.mail.EmailMessage). Untuk mengirim perpaduan teks dan HTML, anda dapat menulis: ``` from django.core.mail import EmailMultiAlternatives subject, from_email, to = 'hello', 'from@example.com', 'to@example.com' text_content = 'This is an important message.' html_content = '

This is an important message.

' msg = EmailMultiAlternatives(subject, text_content, from_email, [to]) msg.attach_alternative(html_content, "text/html") msg.send() ``` Secara awalan, jenis MIME dari parameter `body` dalam sebuah [`EmailMessage`](#django.core.mail.EmailMessage) adalah `"text/plain"`. Itu adalah praktik bagus untuk meninggalkan ini sendiri, karena itu menjamin penerima manapun akan dapat membaca surel, tidak peduli dari surat klien mereka. Bagaimanapun, jika anda sedang percaya diri bahwa penerima anda dapat menangani sebuah jenis isi lain, anda dapat menggunakan atribut `content_subtype` pada kelas [`EmailMessage`](#django.core.mail.EmailMessage) untuk merubah jenis isi utama. Jenis utama akan selalu `"text"`, tetapi anda dapat merubah subjenis. Sebagai contoh: ``` msg = EmailMessage(subject, html_content, from_email, [to]) msg.content_subtype = "html" # Main content is now text/html msg.send() ``` ## Backend email Pengiriman sebenarnya dari sebuah surel ditangani oleh backend email. Kelas backend surel mempunyai metode-metode berikut: - `open()` instantiates a long-lived email-sending connection. - `close()` menutup hubungan mengirim-surel saat ini. - `send_messages(email_messages)` sends a list of [`EmailMessage`](#django.core.mail.EmailMessage) objects. If the connection is not open, this call will implicitly open the connection, and close the connection afterward. If the connection is already open, it will be left open after mail has been sent. Itu dapat juga digunakan sebagai pengelola konteks, yang akan otomatis memanggil `open()` dan `close()` sesuai kebutuhan: ``` from django.core import mail with mail.get_connection() as connection: mail.EmailMessage( subject1, body1, from1, [to1], connection=connection, ).send() mail.EmailMessage( subject2, body2, from2, [to2], connection=connection, ).send() ``` ### Mengambil sebuah instance dari sebuah backend surel. Fungsi [`get_connection()`](#django.core.mail.get_connection) dalam `django.core.mail` mengembalikan sebuah instance dari backend surel yang anda dapat gunakan. #### `get_connection(backend=None, fail_silently=False, *args, **kwargs)` Secara awalan, sebuah panggilan pada `get_connection()` akan mengembalikan sebuah instance dari backend surel ditentukan dalam [`EMAIL_BACKEND`](/id/4.0/ref/settings/#std-setting-EMAIL_BACKEND). Jika anda menentukan argumen `backend`, sebuah instance dari backend itu akan diinstasiasikan. Argumen `fail_silently` mengendalikan bagaimana backend harus menangani kesalahan. Jika `fail_silently` adalah True, pengecualian selama pengolahan mengirim surel akan secara diam diabaikan. Semua argumen lain dilewatkan langsung ke pembangun dari backend surel. Django dikirim dengan beberapa backend pengiriman surel. Dengan pengecualian dari backend SMTP (yaitu awalan), backend ini hanya berguna selama percobaan dan pengembangan. Jika anda mempunyai persyaratan mengirim surel khusus, anda dapat [write your own email backend](#topic-custom-email-backend). #### Backend SMTP #### `class backends.smtp.EmailBackend(host=None, port=None, username=None, password=None, use_tls=None, fail_silently=False, use_ssl=None, timeout=None, ssl_keyfile=None, ssl_certfile=None, **kwargs)` Ini adalah backend awalan. Surel akan dikirim melalui peladen SMTP. Nilai untuk setiap argumen diambil dari pencocokan pengaturan jika argumen adalah `None`: - `host`: [`EMAIL_HOST`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST) - `port`: [`EMAIL_PORT`](/id/4.0/ref/settings/#std-setting-EMAIL_PORT) - `username`: [`EMAIL_HOST_USER`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST_USER) - `password`: [`EMAIL_HOST_PASSWORD`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST_PASSWORD) - `use_tls`: [`EMAIL_USE_TLS`](/id/4.0/ref/settings/#std-setting-EMAIL_USE_TLS) - `use_ssl`: [`EMAIL_USE_SSL`](/id/4.0/ref/settings/#std-setting-EMAIL_USE_SSL) - `timeout`: [`EMAIL_TIMEOUT`](/id/4.0/ref/settings/#std-setting-EMAIL_TIMEOUT) - `ssl_keyfile`: [`EMAIL_SSL_KEYFILE`](/id/4.0/ref/settings/#std-setting-EMAIL_SSL_KEYFILE) - `ssl_certfile`: [`EMAIL_SSL_CERTFILE`](/id/4.0/ref/settings/#std-setting-EMAIL_SSL_CERTFILE) Backend SMTP adalah konfigurasi awalan diwarisi oleh Django. Jika anda ingin menentukan itu secara jelas, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend' ``` Jika tidak ditentukan, `timeout` awalan akan berupa satu disediakan oleh [`socket.getdefaulttimeout()`](https://docs.python.org/3/library/socket.html#socket.getdefaulttimeout), yang awalan pada `None` (tidak ada waktu habis). #### Backend konsol Daripada mengirim keluar surel asli backend konsol hanya menulis surel yang akan dikirim ke keluaran standar. Secara awalan, backend konsol menulis ke `stdout`. Anda dapat menggunakan obyek aliran-seperti berbeda dengan menyediakan argumen katakunci `stream` ketika membangun hubungan. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend' ``` Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan. #### Backend berkas Backend berkas menulis surel pada sebuah berkas. Sebuah berkas baru dibuat untuk setiap sesi baru yang terbuka pada backend ini. Direktori dimana berkas-berkas ditulis adalah baik diambil dari pengaturan [`EMAIL_FILE_PATH`](/id/4.0/ref/settings/#std-setting-EMAIL_FILE_PATH) atau dari katakunci `file_path` ketika membuat sebuah hubungan dengan [`get_connection()`](#django.core.mail.get_connection). Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend' EMAIL_FILE_PATH = '/tmp/app-messages' # change this to a proper location ``` Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan. #### backend di-memory Backend `'locmem'` menyimpan pesan-pesan dalam atribut khusus dari modul `django.core.mail`. Atribut `outbox` dibuat ketika pesan pertama dikirim. Itu adalah daftar dalam sebuah instance [`EmailMessage`](#django.core.mail.EmailMessage) untuk setiap pesan yang akan dikirim. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend' ``` Backend ini tidak dimaksudkan untuk digunakan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan dan percobaan. Django's test runner [automatically uses this backend for testing](/id/4.0/topics/testing/tools/#topics-testing-email). #### Backend tiruan Ketika nama menganjurkan backend tiruan tidak melakukan apapun dengan pesan-pesan anda. Untuk menentukan backend ini, taruh berikut dalam pengaturan anda: ``` EMAIL_BACKEND = 'django.core.mail.backends.dummy.EmailBackend' ``` Backend ini tidak diperuntukkan untuk penggunaan dalam produksi -- itu disediakan sebagai kenyamanan yang dapat digunakan selama pengembangan. ### Menentukan penyesuaian backend surel Jika anda butuh merubah bagaimana surel dikirim anda dapat menulis backend surel anda sendiri. Pengaturan [`EMAIL_BACKEND`](/id/4.0/ref/settings/#std-setting-EMAIL_BACKEND) dalam berkas pengaturan anda adalah kemudian Pythn mengimpor jalur untuk kelas backend anda. Backend surel penyesuaian harus subkelas `BaseEmailBackend` yaitu bertempat dalam modul `django.core.mail.backends.base`. Sebuah backend surel penyesuaian harus menerapkan metode `send_messages(email_messages)`. Metode ini menerima daftar dari instance [`EmailMessage`](#django.core.mail.EmailMessage) dan mengembalikan sejumlah dari pesan-pesan terkirim. Jika backend anda mempunyai konsep apapun dari sesi atau hubungan yang gigih, anda harus juga menerapkan metode `open()` dan `close()`. Mengacu pada `smtp.EmailBackend` untuk penerapan acuan. ### Mengirim banyak surel Membangun dan menutup hubungan SMTP (atau hubungan jaringan lain, untuk masalah itu) adalah sebuah pengolahan yang mahal. Jika anda mempunyai banyak surel untuk dikirim, itu masuk akal menggunakan kembali hubungan SMTP, daripada membuat dan manghancurkan hubungan setiap kali anda ingin mengirim surel. Ada dua cara memberitahu sebuah backend surel untuk menggunakan kembali sebuah hubungan. Pertama-tama, anda dapat menggunakan metode `send_messages()`. `send_messages()` mengambil daftar dari instance [`EmailMessage`](#django.core.mail.EmailMessage) (atau subkelas), dan mengirim mereka semua menggunakan hubungan tunggal. Sebagai contoh, jika anda mempunyai sebuah fungsi dipanggil `get_notification_email()` yang mengembalikan daftar dari obyek [`EmailMessage`](#django.core.mail.EmailMessage) mewakili beberapa surel berkala anda ingin kirimkan, anda dapat mengirim surel ini menggunakan panggilan tunggal untuk send\_messages: ``` from django.core import mail connection = mail.get_connection() # Use default email connection messages = get_notification_email() connection.send_messages(messages) ``` Dalam contoh ini, panggilan pada `send_messages()` membuka hubungan pada backend, mengirim daftar pesan-pesan, dan kemudian menutup hubungan kembali. Pendekatan kedua adalah menggunakan metode `open()` dan `close()` pada backend surel untuk secara manual mengendalikan hubungan. `send_messages()` tidak akan secara manual membuka atau menutup hubungan jika itu sudah terbuka, jadi jika anda membuka secara munual hubungan, anda dapat mengendalikan ketika itu tertutup. Sebagai contoh: ``` from django.core import mail connection = mail.get_connection() # Manually open the connection connection.open() # Construct an email message that uses the connection email1 = mail.EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to1@example.com'], connection=connection, ) email1.send() # Send the email # Construct two more messages email2 = mail.EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to2@example.com'], ) email3 = mail.EmailMessage( 'Hello', 'Body goes here', 'from@example.com', ['to3@example.com'], ) # Send the two emails in a single call - connection.send_messages([email2, email3]) # The connection was already open so send_messages() doesn't close it. # We need to manually close the connection. connection.close() ``` ## Konfigurasi surel untuk pengembangan Ada saatnya ketika anda tidak ingn Django mengirim surel sama sekali. Sebagai contoh, selagi mengembangkan sebuah situs jaringan, anda mungkin tidak ingin mengirim ribuan surel -- tetapi anda mungkin ingin mensahkan surel akan dikirim ke orang benar dibawah suasana yang benar, dan surel itu akan mengandung isi benar. The easiest way to configure email for local development is to use the [console](#topic-email-console-backend) email backend. This backend redirects all email to `stdout`, allowing you to inspect the content of mail. Backend surel [file](#topic-email-file-backend) dapat berguna selama pengembangan -- backend ini membuang isi dari setiap hubungan SMTP ke sebuah berkas yang dapat diperiksa pada waktu luang anda. Another approach is to use a "dumb" SMTP server that receives the emails locally and displays them to the terminal, but does not actually send anything. The [aiosmtpd](https://aiosmtpd.readthedocs.io/en/latest/) package provides a way to accomplish this: ``` python -m pip install aiosmtpd python -m aiosmtpd -n -l localhost:8025 ``` This command will start a minimal SMTP server listening on port 8025 of localhost. This server prints to standard output all email headers and the email body. You then only need to set the [`EMAIL_HOST`](/id/4.0/ref/settings/#std-setting-EMAIL_HOST) and [`EMAIL_PORT`](/id/4.0/ref/settings/#std-setting-EMAIL_PORT) accordingly. For a more detailed discussion of SMTP server options, see the documentation of the [aiosmtpd](https://aiosmtpd.readthedocs.io/en/latest/) module. For information about unit-testing the sending of emails in your application, see the [Layanan surel](/id/4.0/topics/testing/tools/#topics-testing-email) section of the testing documentation.